Introduction
En Common Lisp, comme dans beaucoup de langages, les nombres se déclinent en plusieurs types, dont voici les deux plus fondamentaux :
Les entiers
Comme beaucoup de langages, Common Lisp dispose d'entiers.
Ce sont des nombres entiers sans séparateur décimal (comme -6, 0, 25, 1234, etc.).
Common Lisp n'impose aucune limite à la taille des entiers.
Un entier peut être arbitrairement grand (ou petit s'il est négatif).
En général, si tu ne manipules que des nombres entiers, il vaut mieux privilégier les entiers, car ils ne souffrent pas de la même perte de précision que les nombres à virgule flottante au fil des calculs.
Les nombres à virgule flottante
Comme beaucoup de langages, Common Lisp dispose de nombres à virgule flottante.
Ce sont des nombres fractionnaires ou entiers comportant un séparateur décimal (comme 3.14, -1.7, 99.99, 2048.0).
Arithmétique
Common Lisp utilise les opérateurs arithmétiques habituels pour la plupart des opérations, mais se distingue par l'usage d'une « notation préfixe » plutôt que de la « notation infixe » plus familière.
Pour mieux visualiser :
;; Infix-notation (non-lisp languages)
1 + 2 + 3 + 4 + 5 ; => 15
;; Prefix-notation (lisp languages)
(+ 1 2 3 4 5) ; => 15
Si la notation préfixe transforme certaines opérations comme 2 + 2 en une forme un peu déroutante, (+ 2 2), elle facilite grandement les opérations sur plusieurs nombres à la fois.
Opérations arithmétiques de base
Common Lisp dispose de toutes les fonctions classiques : +, -, *, / pour l'addition, la soustraction, la multiplication et la division.
Pour la division, on peut vouloir connaître le reste d'une division : c'est le rôle de la fonction mod (pour modulo), qui prend un nombre et un diviseur en arguments :
(mod 4 2) ; => 0
(mod 2 4) ; => 2
(mod 10 3) ; => 1
Comparer des nombres
Enfin, il peut être utile de comparer différents nombres à l'aide de fonctions comme = (égal), /= (différent de) et >= (supérieur ou égal à).
Quand ces comparaisons sont vraies (comme dans (= 1 1)), elles renvoient T, et quand elles ne le sont pas (comme dans (> 0 1)), elles renvoient NIL.
Instructions
Lilly, l'extraterrestre Lisp, adore cuisiner. Elle veut organiser une soirée pizza avec ses amis, mais pour profiter au maximum de ses ingrédients, elle aimerait savoir exactement de quelle quantité de chaque ingrédient elle aura besoin avant de commencer.
Pour résoudre ce problème, Lilly a ébauché un programme qui automatise une partie de la planification, mais elle a besoin de ton aide pour le terminer.
Vas-tu aider Lilly à organiser la soirée pizza aux proportions parfaites ?
1. Un ratio de pâte
Commençons par le début : toute bonne pizza commence par une pâte délicieuse !
Lilly adore les pizzas fines et croustillantes, avec une croûte plus épaisse.
La pâte nécessaire pour le centre est de 200 g, une valeur constante, mais chaque 20 cm de croûte demande 45 g de pâte.
Heureusement, Lilly a calculé l'équation qui donne les grammes de pâte (g) à partir du nombre de pizzas (n) et de leur diamètre (d) :
g = n * (((45 * pi * d) / 20) + 200)
Lilly a besoin d'une fonction qui :
- prend le nombre de pizzas (n) et leur diamètre (d),
- et renvoie la pâte nécessaire, arrondie au gramme près (g).
Par exemple, pour faire 4 pizzas de 30 cm de diamètre :
(dough-calculator 4 30) ; => 1648
2. Un filet de sauce
Lilly est méticuleuse quand elle étale sa sauce, mais la taille de ses pizzas peut varier.
Pour déterminer le diamètre (d), elle utilise l'équation ci-dessous, avec la sauce appliquée (s) comme variable :
d = square-root of ((40 * s) / (3 * pi))
Lilly a besoin d'une fonction qui calcule le diamètre de la pizza (d) à partir de chaque millilitre de sauce appliquée (s).
Par exemple, si Lilly a utilisé 250 ml de sauce :
(size-from-sauce 250) ; => 32.57
3. Un peu de fromage, s'il te plaît
Sur la planète de Lilly, tout le fromage se présente en cubes parfaits et se vend à la taille.
(Tu t'attendais à quoi ? C'est une planète extraterrestre, après tout...)
Une fois encore, Lilly a calculé une équation pour le nombre de pizzas (n) d'un certain diamètre (d) que l'on peut faire à partir d'un cube de fromage d'arête (l) :
n = (2 * (l^3)) / (3* pi * (d^2))
Crée une fonction qui :
- prend l'arête d'un cube de fromage (l) et le diamètre des pizzas (d),
- et renvoie le nombre de pizzas (n) réalisables, arrondi à l'entier inférieur.
Par exemple, avec un cube de fromage de 25x25x25 cm et des pizzas de 30 cm de diamètre :
(pizzas-per-cube 25 30) ; => 3
4. Un partage équitable
Enfin, Lilly veut que ses pizzas soient coupées en 8 parts chacune et réparties équitablement entre ses amis.
Crée une fonction qui :
- prend un nombre de pizzas et un nombre d'amis
- et renvoie
T si les pizzas se répartissent équitablement entre les amis, et NIL sinon.
Par exemple :
;; For splitting 3 pizzas between 4 friends
(fair-share-p 3 4) ; => T
;; For splitting 2 pizzas between 3 friends
(fair-share-p 2 3) ; => NIL
Exercice d'apprentissage
