Nommer, ranger, calculer, lire et écrire
Département de Mathématiques et Informatique, Faculté des Sciences et Techniques, Université Cheikh Anta Diop de Dakar
Ce que la séance construit
La variable, case nommée qui garde une valeur d’un type donné : sa déclaration, l’affectation \(\leftarrow\) qui y range une valeur, Lire et Écrire qui relient l’algorithme au clavier et à l’écran, les expressions qui calculent avec \(+\), \(-\), \(\times\), \(/\), div et mod. Chaque algorithme est suivi pas à pas dans une trace d’exécution : la ligne exécutée, l’état des variables, ce qu’écrit Écrire.
D’où l’on vient, où l’on va
Amont. Un algorithme est une suite d’instructions exécutées à la main, dans l’ordre, entre Début et Fin (Séance 0). Il lui manque une mémoire : un endroit où ranger une donnée lue ou un résultat, pour s’en servir plus loin.
Aval. Les conditions (Séance 2) comparent des valeurs de variables et choisissent les lignes à exécuter ; les boucles (Séance 3) répètent des affectations comme s \(\leftarrow\) s + x ; le tableau (Séance 4) range plusieurs valeurs sous un seul nom.
| écriture | sens |
|---|---|
Algorithme Nom / Variables / Début / Fin |
en-tête (nom à initiale majuscule, sans accent : Duree), déclarations (absentes s’il n’y a pas de variable), instructions |
x : entier ; a, b : réel |
déclaration : nom et type ; un type par ligne |
650 ; 12,5 ; vrai ; 'B' ; "Awa" |
entier, réel (virgule), booléen, caractère, chaîne |
| \(x\leftarrow e\) | \(x\) reçoit la valeur de \(e\) (lire « \(x\) reçoit \(e\) ») ; l’ancienne valeur est perdue |
Lire n |
n reçoit la valeur tapée au clavier, une valeur par ligne |
Écrire "prix :", p |
écrit les valeurs séparées par une espace, puis passe à la ligne : prix : 650 |
| réel lu ou écrit ; booléen écrit | virgule, au moins une décimale (13,5, 12,0) ; écrit : la plus courte écriture de la valeur rangée en machine (au plus 17 chiffres significatifs) ; entier tapé pour un réel : 20 devient 20,0 ; vrai ou faux |
// texte |
commentaire jusqu’à la fin de la ligne ; ignoré à l’exécution |
| retrait de 2 espaces | sous Variables et entre Début et Fin |
Un nom de variable commence par une lettre, suivie de lettres ou de chiffres, sans espace ni accent : prix, n1, b5000.
| écriture | sens |
|---|---|
| \(+\ -\ \times\ /\) | opérations ; \(/\) donne toujours un réel : \(6/3\) donne 2,0 |
| div, mod | quotient et reste de la division entière de deux entiers : \(7\) div \(2=3\), \(7\) mod \(2=1\) |
| priorités | \(\times\), \(/\), div, mod avant \(+\), \(-\) ; à égalité, de gauche à droite ; parenthèses d’abord |
| type d’un résultat | entier si tous les opérandes sont entiers (sauf \(/\)), réel sinon ; un entier rangé dans un réel devient un réel (5 donne 5,0) |
| erreur : arrêt de l’exécution | variable sans valeur utilisée ; division par zéro (\(/\), div, mod) ; valeur d’un autre type que la variable (un réel dans un entier) |
| trace | une ligne par pas : ligne exécutée, valeurs après le pas ; en-tête, déclarations, Début, Fin : aucun pas |
| forme courte | instructions seules, numérotées à partir de 1 ; en-tête, partie Variables, Début, Fin sous-entendus ; un tableau (Séance 4) se déclare parmi les instructions (un pas) ; Début et Fin reviennent en Séance 5 (programme principal) |
Les deux formes donnent la même trace tant que chaque valeur est du type de sa variable. Sans déclarations, la forme courte n’a pas de contrôle de type ; dans les séances suivantes, chaque variable garde le type de sa première valeur.
Au marché Tilène, pour payer 3 kg d’oignons à 650 F le kilo (prix illustratif), il faut retenir le prix du kilo, puis le multiplier : un algorithme range ce qu’il retient dans des variables.
Variable
Une variable est une case de la mémoire désignée par un nom ; elle contient une valeur d’un type fixé à la déclaration, et garde cette valeur jusqu’à ce qu’une instruction en range une autre.
Lecture. Cinq variables, cinq types. Une variable déclarée n’a pas encore de valeur : sa case est vide jusqu’à la première affectation ou au premier Lire.
| type | valeurs | exemples | opérations de la séance |
|---|---|---|---|
| entier | nombres sans partie décimale | 650, 0, -15 |
\(+\), \(-\), \(\times\), div, mod ; \(/\) donne un réel |
| réel | nombres à virgule | 12,5, 0,03, 12,0 |
\(+\), \(-\), \(\times\), \(/\) |
| booléen | deux valeurs | vrai, faux |
rangées, écrites (calculées en Séance 2) |
| caractère | un seul symbole, entre apostrophes | 'B', '7' |
rangés, écrits |
| chaîne | suite de caractères, entre guillemets | "Awa", "à payer :" |
rangées, écrites |
Même écriture, types différents
12 est un entier, 12,0 un réel : même nombre, deux types. '7' est un caractère et "650" une chaîne : ni l’un ni l’autre n’est un nombre, et aucun calcul ne s’y applique.
Lecture. Le type dit quelles valeurs la case accepte et quelles opérations ont un sens : on multiplie deux prix, on ne multiplie pas deux noms.
Trois parties
// : un commentaire, pour le lecteur, ignoré à l’exécution.Lecture. Seules les lignes 6 à 9 s’exécutent : elles seules produisent un pas dans une trace. Le retrait de deux espaces montre ce qui appartient à Variables et au corps.
Une variable reçoit une valeur de deux façons : par une affectation, ou par Lire.
\(x\leftarrow e\)
Calculer la valeur de l’expression \(e\) avec les valeurs actuelles des variables, puis la ranger dans \(x\). L’ancienne valeur de \(x\) est perdue ; les variables de \(e\) ne changent pas.
Lecture. La flèche va de droite à gauche : la valeur calculée à droite entre dans la case nommée à gauche. À gauche de \(\leftarrow\), toujours une seule variable ; à droite, une expression : 5, b, a + 1, prix × qte.
{Lire \(x\)}
L’exécution attend une valeur tapée au clavier et la range dans \(x\), comme une affectation. Une valeur par Lire, de la forme du type de \(x\) : 650, 12,5, Awa (une chaîne se tape sans guillemets).
{Écrire \(e_1\), \(e_2\), …}
Écrit les valeurs des expressions, séparées par une espace, puis passe à la ligne. Un texte entre guillemets est écrit tel quel, sans les guillemets ; Écrire ne modifie aucune variable.
| instruction | valeurs | ligne écrite |
|---|---|---|
Écrire “à payer :”, total |
total \(=\) 1950 |
à payer : 1950 |
Écrire “moyenne :”, moy |
moy \(=\) 12,0 |
moyenne : 12,0 |
Écrire nom, classe, prix, paye |
nom \(=\) "Awa", classe \(=\) 'B', prix \(=\) 3500, paye \(=\) faux |
Awa B 3500 faux |
Écrire a, b |
a \(=\) 8, b \(=\) 3 |
8 3 |
Lecture. Un réel s’écrit avec une virgule et au moins une décimale, un booléen par vrai ou faux ; les espaces de la ligne écrite viennent des séparateurs et des textes.
Entrée au clavier : 650 ; 3
Écrit par Écrire \(\rightarrow\)
à payer : 1950
Écrit par Écrire \(\rightarrow\)
17 9Lecture. Ligne 5 : a reçoit 5.
Lecture. Ligne 6 : b reçoit a + 3, soit 5 + 3 \(=\) 8.
Lecture. Ligne 7 : a ← b × 2, soit 8 × 2 \(=\) 16 ; a passe de 5 à 16. b garde 8 : la ligne 6 a rangé une valeur dans b, pas un lien avec a.
Lecture. Ligne 8 : a ← a + 1, soit 16 + 1 \(=\) 17 ; a passe de 16 à 17. a figure des deux côtés : la droite est calculée avec l’ancienne valeur, 16, puis rangée dans a.
Lecture. Ligne 9 : b ← a - b, soit 17 - 8 \(=\) 9 ; b passe de 8 à 9.
Lecture. Ligne 10 : Écrire écrit « 17 9 » ; l’algorithme est terminé. a a reçu trois valeurs, 5, 16 et 17 : seule la dernière reste.
Trois variables, six affectations
x, y et z après chaque ligne de 5 à 10.x est perdue, et à quelle ligne ?Correction
| ligne | x |
y |
z |
|---|---|---|---|
| 5 | 4 | ||
| 6 | 4 | 12 | |
| 7 | 4 | 12 | 8 |
| 8 | 20 | 12 | 8 |
| 9 | 20 | 13 | 8 |
| 10 | 20 | 13 | 7 |
20 13 7 : \(20\) mod \(13=7\).x.20 13 8 : z reçoit \(20\) mod \(12=8\), y valant encore 12 ; l’ordre compte.
Entrée au clavier : 3 ; 8
Écrit par Écrire \(\rightarrow\)
8 8Lecture. Ligne 5 : Lire a ; l’entrée au clavier donne a \(=\) 3.
Lecture. Ligne 6 : Lire b ; l’entrée au clavier donne b \(=\) 8.
Lecture. Ligne 7 : a ← b ; a passe de 3 à 8, la valeur de b.
Lecture. Ligne 8 : b ← a ; b reçoit la valeur de a, 8, qu’elle avait déjà. La valeur 3 a disparu au pas 3 : plus aucune variable ne la contient.
Lecture. Ligne 9 : Écrire écrit « 8 8 » ; l’algorithme est terminé. Les deux variables valent 8 : l’échange a échoué.
Entrée au clavier : 3 ; 8
Écrit par Écrire \(\rightarrow\)
8 3Lecture. Ligne 5 : Lire a ; l’entrée au clavier donne a \(=\) 3.
Lecture. Ligne 6 : Lire b ; l’entrée au clavier donne b \(=\) 8.
Lecture. Ligne 7 : tmp reçoit la valeur de a, soit 3. tmp garde une copie de a avant que la ligne 8 ne l’écrase.
Lecture. Ligne 8 : a ← b ; a passe de 3 à 8, la valeur de b.
Lecture. Ligne 9 : b ← tmp ; b passe de 8 à 3, la valeur de tmp.
Lecture. Ligne 10 : Écrire écrit « 8 3 » ; l’algorithme est terminé. Trois affectations et une variable de plus : a et b ont échangé leurs valeurs.
À droite de \(\leftarrow\), une expression combine des valeurs et des variables par des opérateurs ; son évaluation suit des priorités, comme en calcul.
| opérateurs | priorité | exemple (\(a=7\), \(b=2\)) |
|---|---|---|
| ( … ) | d’abord | (a + b) × 3 donne 27 |
| \(\times\) \(/\) div mod | puis, de gauche à droite | a + b × 3 donne 13 ; a × b div 3 donne 4 |
| \(+\) \(-\) | enfin, de gauche à droite | a - b - 1 donne 4 |
La division réelle donne toujours un réel
a / b donne 3,5 ; 6 / 3 donne 2,0, et non 2. Pour un résultat entier, il faut div : a div b donne 3. Un réel rangé dans une variable entière arrête l’exécution.
Lecture. Dans le doute, des parenthèses : elles ne coûtent rien et disent l’ordre voulu.
{\(a\) div \(b\) et \(a\) mod \(b\), pour deux entiers \(a\geq0\) et \(b>0\)}
\(q=a\) div \(b\) est le nombre de fois que \(b\) tient entièrement dans \(a\) ; \(r=a\) mod \(b\) est ce qui reste : \(a=b\times q+r\), avec \(0\leq r<b\).
Une durée en minutes devient des heures et des minutes ; une somme devient des billets et un reste ; n mod 10 donne le chiffre des unités de \(n\), n div 10 le nombre sans ce chiffre.
Lecture. div et mod s’appliquent à deux entiers ; un diviseur nul arrête l’exécution, comme pour \(/\).
Entrée au clavier : 263
Écrit par Écrire \(\rightarrow\)
263 min = 4 h 23 minLecture. Ligne 5 : Lire duree ; l’entrée au clavier donne duree \(=\) 263.
Lecture. Ligne 6 : h reçoit duree div 60, soit 263 div 60 \(=\) 4.
Lecture. Ligne 7 : mn reçoit duree mod 60, soit 263 mod 60 \(=\) 23.
Lecture. Ligne 8 : Écrire écrit « 263 min = 4 h 23 min » ; l’algorithme est terminé. Vérification : \(60\times4+23=263\).
Entrée au clavier : 17500
Écrit par Écrire \(\rightarrow\)
3 1 0 500Lecture. Ligne 5 : Lire r ; l’entrée au clavier donne r \(=\) 17500. r : la somme qui reste à rendre ; chaque mod la remplace par un reste.
Lecture. Ligne 6 : b5000 reçoit r div 5000, soit 17500 div 5000 \(=\) 3.
Lecture. Ligne 7 : r ← r mod 5000, soit 17500 mod 5000 \(=\) 2500 ; r passe de 17500 à 2500.
Lecture. Ligne 8 : b2000 reçoit r div 2000, soit 2500 div 2000 \(=\) 1.
Lecture. Ligne 9 : r ← r mod 2000, soit 2500 mod 2000 \(=\) 500 ; r passe de 2500 à 500.
Lecture. Ligne 10 : b1000 reçoit r div 1000, soit 500 div 1000 \(=\) 0.
Lecture. Ligne 11 : r ← r mod 1000, soit 500 mod 1000 \(=\) 500 ; r reçoit 500, la valeur qu’elle avait déjà.
Lecture. Ligne 12 : Écrire écrit « 3 1 0 500 » ; l’algorithme est terminé. 3 billets de 5000 F, 1 de 2000 F, aucun de 1000 F, 500 F en pièces ou en billet de 500 F : \(15000+2000+500=17500\).
Entrée au clavier : 12 ; 15 ; 9
Écrit par Écrire \(\rightarrow\)
moyenne : 12,0Lecture. Ligne 6 : Lire n1 ; l’entrée au clavier donne n1 \(=\) 12.
Lecture. Ligne 7 : Lire n2 ; l’entrée au clavier donne n2 \(=\) 15.
Lecture. Ligne 8 : Lire n3 ; l’entrée au clavier donne n3 \(=\) 9.
Lecture. Ligne 9 : moy reçoit (n1 + n2 + n3) / 3, soit (12 + 15 + 9) / 3 \(=\) 12,0. / donne un réel, même quand la division tombe juste : 12,0 et non 12.
Lecture. Ligne 10 : Écrire écrit « moyenne : 12,0 » ; l’algorithme est terminé.
Temps d’une course, en secondes (illustratif)
t, h, mn et s après chaque ligne.h, mn et s ?Correction
t lu |
h |
mn |
s |
sans la ligne 7 |
|---|---|---|---|---|
| 8125 | 2 | 15 | 25 | 2 h 135 min 25 s |
| 3600 | 1 | 0 | 0 | 1 h 60 min 0 s |
| 59 | 0 | 0 | 59 | 0 h 0 min 59 s |
t le reste, 925 ; \(925\) div \(60=15\), \(925\) mod \(60=25\).1 h 0 min 0 s et 0 h 0 min 59 s : un quotient nul est un résultat.mn compte toutes les minutes, heures comprises (case orange).h × 3600 + mn × 60 + s : \(7200+900+25=8125\).Les erreurs de la séance viennent presque toutes d’une lecture fausse de la flèche.
Quoi
\(x\leftarrow e\) est un ordre, exécuté une fois, de droite à gauche : calculer \(e\), puis ranger le résultat dans \(x\). Ce n’est pas une égalité : a \(\leftarrow\) b et b \(\leftarrow\) a sont deux instructions différentes, et n \(\leftarrow\) n + 1 augmente n de 1.
Pourquoi les types et les valeurs initiales
Une expression n’est calculable que si chacune de ses variables a une valeur ; le résultat doit être du type de la variable qui le reçoit.
Quand ça échoue
total \(\leftarrow\) total + achat sans valeur initiale de total : arrêt. part \(\leftarrow\) somme / 4 avec part entière : arrêt, il faut div. (n1 + n2 + n3) / 3 sans parenthèses : seule n3 est divisée. a \(\leftarrow\) b, puis b \(\leftarrow\) a : deux copies de b, pas un échange.
Entrée au clavier : 2500
Écrit par Écrire \(\rightarrow\)
arrêt : total sans valeurLecture. Ligne 5 : Lire achat ; l’entrée au clavier donne achat \(=\) 2500.
Lecture. Ligne 6 : total + achat demande la valeur de total, qui n’en a reçu aucune : arrêt de l’exécution. Déclarer une variable ne lui donne pas de valeur : il fallait total \(\leftarrow\) 0 avant la ligne 6.
Devoir d (coefficient 1), examen e (coefficient 2)
d + 2 × e, puis de cette somme / 3, div 3 et mod 3.m \(\leftarrow\) d + 2 × e / 3. Qu’écrit l’algorithme ?d, e, m : entier (une ligne). Que se passe-t-il à la ligne 7 ? Que faut-il écrire ?Correction
| expression | valeur | type |
|---|---|---|
d + 2 × e |
42 | entier |
(d + 2 × e) / 3 |
14,0 | réel |
| <code>(d + 2 × e) div 3</code> | 14 | entier |
| <code>(d + 2 × e) mod 3</code> | 0 | entier |
d + 2 × e / 3 |
22,0 | réel |
moyenne : 14,0 : \((12+30)/3\), un réel.moyenne : 22,0 : \(2\times15/3\) est calculé d’abord, puis ajouté à 12 (case orange).(d + 2 × e) div 3 ; pour 13 et 15, div donne 14 et perd la partie décimale de \(43/3\).| instruction | effet | pas | arrêt possible |
|---|---|---|---|
x : entier |
crée la case x, sans valeur |
aucun | — |
| \(x\leftarrow e\) | calcule \(e\), range la valeur dans \(x\) | 1 | variable sans valeur, division par zéro, type |
Lire x |
range dans x la valeur tapée |
1 | valeur d’un autre type |
| Écrire \(e_1\), \(e_2\) | écrit les valeurs, passe à la ligne | 1 | variable sans valeur, division par zéro |
À retenir
n \(\leftarrow\) n + 1 n’est pas une équation.tmp \(\leftarrow\) a, a \(\leftarrow\) b, b \(\leftarrow\) tmp.Séance 2 — Les conditions
Jusqu’ici, toutes les lignes s’exécutent, une fois chacune, dans l’ordre. Une condition, comparaison de valeurs dont le résultat est un booléen, décide des lignes à exécuter : Si … Alors … Sinon … FinSi ; les conditions se combinent par ET, OU, NON.
À préparer : pour un achat de 15000 F, puis de 25000 F, calculer à la main le prix à payer quand la livraison coûte 1000 F mais est offerte à partir de 20000 F d’achat ; relever ce qui change d’un cas à l’autre.
Algorithmique — Séance 1 Dr. El Hadji Bassirou TOURÉ • DMI/FST/UCAD
Lecture. Ligne 5 : Lire
prix; l’entrée au clavier donneprix\(=\) 650.Lecture. Ligne 6 : Lire
qte; l’entrée au clavier donneqte\(=\) 3.Lecture. Ligne 7 :
totalreçoitprix × qte, soit650 × 3\(=\) 1950.Lecture. Ligne 8 : Écrire écrit «
à payer : 1950» ; l’algorithme est terminé. Les lignes 1 à 4 et la ligne 9 ne produisent aucun pas : l’en-tête, les déclarations, Début et Fin ne s’exécutent pas.