Répéter une action, compter, accumuler, s’arrêter
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 boucle, instruction qui répète un bloc tant qu’une condition le demande : ses trois formes (TantQue, Pour, Répéter … Jusqu’à), les deux usages qui reviennent partout (compter, accumuler), les deux erreurs les plus fréquentes (la boucle qui ne s’arrête pas, le tour en trop ou en moins) et les boucles placées l’une dans l’autre. Chaque algorithme est suivi pas à pas : la ligne exécutée, l’état des variables, ce qu’écrit Écrire.
D’où l’on vient, où l’on va
Amont. Variables, affectation et trace d’exécution (Séance 1) ; conditions Si … Alors … Sinon et booléens ET, OU, NON (Séance 2). Une boucle ajoute une condition testée à nouveau après chaque passage dans un bloc.
Aval. Parcourir un tableau (Séance 4), c’est une boucle Pour sur ses indices, avec les compteurs et les accumulateurs de cette séance.
| écriture | sens |
|---|---|
| \(x\leftarrow e\) | \(x\) reçoit la valeur de l’expression \(e\) (lire « \(x\) reçoit ») |
Lire n |
n reçoit la valeur tapée au clavier (une valeur par ligne) |
Écrire "tour", i |
écrit les valeurs séparées par une espace, puis passe à la ligne : tour 1 |
| \(=\) \(\neq\) \(<\) \(\leq\) \(>\) \(\geq\) ; ET, OU, NON | comparaisons et connecteurs logiques (résultat vrai ou faux) |
| \(+\) \(-\) \(\times\) \(/\) ; div, mod | opérations ; quotient et reste de la division entière (\(7\) mod \(2=1\)) |
| TantQue \(C\) Faire … FinTantQue | test de \(C\) avant chaque tour ; de 0 à plusieurs tours |
| Pour \(i\) de \(a\) à \(b\) [pas \(p\)] Faire … FinPour | \(i=a, a+p, \dots\) tant que \(i\leq b\) (\(i\geq b\) si \(p<0\)) ; pas de 1 par défaut |
| Répéter … Jusqu’à \(C\) | corps exécuté, puis test ; sortie quand \(C\) est vraie ; au moins un tour |
| retrait de 2 espaces, mot de fin | délimitent le corps d’une boucle ou d’un Si |
Le compteur d’un Pour
Le corps ne le modifie pas ; sa valeur après FinPour n’est pas définie (un algorithme ne s’en sert pas) ; deux boucles imbriquées ont deux compteurs différents.
Une condition (Séance 2) exécute un bloc au plus une fois ; la boucle le répète.
{TantQue \(C\) Faire \(B\) FinTantQue}
Tant que \(C\) est vraie, exécuter le corps \(B\) (un tour) et tester de nouveau ; sinon, suite.
Lecture. Initialisation, condition, corps, progression ; seule la branche « faux » fait sortir.
Tableau d’état : les 6 derniers pas.
Entrée au clavier : 3
Écrit par Écrire \(\rightarrow\)
tour 1
tour 2
tour 3
fin, i = 4
Tableau d’état : les 8 derniers pas.
Entrée au clavier : 0
Écrit par Écrire \(\rightarrow\)
fin, i = 1Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 0.
Lecture. Ligne 2 : i reçoit 1.
Lecture. Ligne 3 : test i ≤ n, soit 1 ≤ 0 : faux ; la boucle s’arrête ; suite à la ligne 7.
Lecture. Ligne 7 : Écrire écrit « fin, i = 1 ». Le premier test est faux : zéro tour, rien n’est écrit dans la boucle. Une boucle TantQue peut ne jamais exécuter son corps.
Entrées : 7000 puis 30000
semaine, total et du test (ligne 5).Correction
| test | semaine | total | total \(<\) 30000 |
|---|---|---|---|
| 1 | 0 | 0 | vrai |
| 2 | 1 | 7000 | vrai |
| 3 | 2 | 14000 | vrai |
| 4 | 3 | 21000 | vrai |
| 5 | 4 | 28000 | vrai |
| 6 | 5 | 35000 | faux |
5 35000.
Tableau d’état : les 8 derniers pas.
Entrée au clavier : 4
Écrit par Écrire \(\rightarrow\)
somme : 10Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 4.
Lecture. Ligne 2 : s reçoit 0.
Lecture. Ligne 3 : i reçoit 1.
Lecture. Ligne 4 : test i ≤ n, soit 1 ≤ 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 0 à 1.
Lecture. Ligne 6 : i ← i + 1 : i passe de 1 à 2.
Lecture. Ligne 4 : test i ≤ n, soit 2 ≤ 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 1 à 3.
Lecture. Ligne 6 : i ← i + 1 : i passe de 2 à 3.
Lecture. Ligne 4 : test i ≤ n, soit 3 ≤ 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 3 à 6.
Lecture. Ligne 6 : i ← i + 1 : i passe de 3 à 4.
Lecture. Ligne 4 : test i ≤ n, soit 4 ≤ 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 6 à 10.
Lecture. Ligne 6 : i ← i + 1 : i passe de 4 à 5.
Lecture. Ligne 4 : test i ≤ n, soit 5 ≤ 4 : faux ; la boucle s’arrête ; suite à la ligne 8.
Lecture. Ligne 8 : Écrire écrit « somme : 10 ». \(s=1+2+3+4=10\). \(s\) part de 0, l’élément neutre de l’addition : c’est aussi le bon résultat si la boucle ne fait aucun tour.
Tableau d’état : les 8 derniers pas.
Entrée au clavier : 3 ; 12 ; 8 ; 15
Écrit par Écrire \(\rightarrow\)
admis : 2Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 3.
Lecture. Ligne 2 : admis reçoit 0.
Lecture. Ligne 3 : k reçoit 0.
Lecture. Ligne 4 : test k < n, soit 0 < 3 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : Lire note ; l’entrée au clavier donne note \(=\) 12.
Lecture. Ligne 6 : test du Si, 12 ≥ 10 : vrai ; le bloc Alors est exécuté.
Lecture. Ligne 7 : admis ← admis + 1 : admis passe de 0 à 1.
Lecture. Ligne 9 : k ← k + 1 : k passe de 0 à 1.
Lecture. Ligne 4 : test k < n, soit 1 < 3 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : Lire note ; l’entrée au clavier donne note \(=\) 8.
Lecture. Ligne 6 : test du Si, 8 ≥ 10 : faux ; le bloc est sauté.
Lecture. Ligne 9 : k ← k + 1 : k passe de 1 à 2.
Lecture. Ligne 4 : test k < n, soit 2 < 3 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : Lire note ; l’entrée au clavier donne note \(=\) 15.
Lecture. Ligne 6 : test du Si, 15 ≥ 10 : vrai ; le bloc Alors est exécuté.
Lecture. Ligne 7 : admis ← admis + 1 : admis passe de 1 à 2.
Lecture. Ligne 9 : k ← k + 1 : k passe de 2 à 3.
Lecture. Ligne 4 : test k < n, soit 3 < 3 : faux ; la boucle s’arrête ; suite à la ligne 11.
Lecture. Ligne 11 : Écrire écrit « admis : 2 ». admis n’augmente qu’aux tours où le test du Si est vrai (12 et 15) : 2 admis. k, lui, compte tous les tours et commande la boucle.
Tableau d’état : les 8 derniers pas.
Entrée au clavier : 3 ; 31 ; 35 ; 33
Écrit par Écrire \(\rightarrow\)
maximum : 35Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 3.
Lecture. Ligne 2 : Lire x ; l’entrée au clavier donne x \(=\) 31.
Lecture. Ligne 3 : maxi reçoit x, soit 31.
Lecture. Ligne 4 : k reçoit 1.
Lecture. Ligne 5 : test k < n, soit 1 < 3 : vrai ; le corps est exécuté.
Lecture. Ligne 6 : Lire x ; l’entrée au clavier donne x \(=\) 35.
Lecture. Ligne 7 : test du Si, 35 > 31 : vrai ; le bloc Alors est exécuté.
Lecture. Ligne 8 : maxi ← x : maxi passe de 31 à 35.
Lecture. Ligne 10 : k ← k + 1 : k passe de 1 à 2.
Lecture. Ligne 5 : test k < n, soit 2 < 3 : vrai ; le corps est exécuté.
Lecture. Ligne 6 : Lire x ; l’entrée au clavier donne x \(=\) 33.
Lecture. Ligne 7 : test du Si, 33 > 35 : faux ; le bloc est sauté.
Lecture. Ligne 10 : k ← k + 1 : k passe de 2 à 3.
Lecture. Ligne 5 : test k < n, soit 3 < 3 : faux ; la boucle s’arrête ; suite à la ligne 12.
Lecture. Ligne 12 : Écrire écrit « maximum : 35 ». maxi est le plus grand des nombres déjà lus ; il part de la première valeur lue, non de 0.
Quoi
Un compteur augmente de 1 à chaque tour où un événement se produit ; un accumulateur combine à chaque tour sa valeur avec une nouvelle donnée (\(+\) pour une somme, \(\times\) pour un produit, « le plus grand des deux » pour un maximum). Initialisés avant la boucle, mis à jour dans le corps, lus après.
Pourquoi la valeur initiale
Après \(k\) tours, l’accumulateur contient le résultat sur les \(k\) premières données (\(s_k=x_1+\dots+x_k\)) ; pour que ce soit vrai dès \(k=0\) (\(k=1\) pour un maximum), il part de l’élément neutre (0 pour une somme, 1 pour un produit) ou, pour un maximum, de la première donnée.
Quand ça échoue
Produit initialisé à 0 : il reste nul. Maximum initialisé à 0 sur \(-3\), \(-7\), \(-2\) : 0 au lieu de \(-2\). Initialisation placée dans le corps : remise à zéro à chaque tour.
Dans la somme, les lignes \(i\leftarrow1\), \(i\leq n\) et \(i\leftarrow i+1\) font varier un compteur de 1 à \(n\) : quand le nombre de tours est connu avant d’entrer, Pour les réunit en une ligne.
{Pour \(i\) de \(a\) à \(b\) Faire \(B\) FinPour}
Exécuter \(B\) une fois pour chaque valeur entière de \(i\) de \(a\) à \(b\), bornes incluses, dans l’ordre croissant ; avec pas \(p\), \(i\) avance de \(p\) (compte à rebours si \(p<0\)).
Équivalence et nombre de tours
\[ \textbf{Pour}\ i\ \textbf{de}\ a\ \textbf{à}\ b\ \equiv\ i\leftarrow a~;\ \textbf{TantQue}\ i\leq b\ \textbf{Faire}\ \big(B~;\ i\leftarrow i+1\big) \]
\[ \text{tours}=\max(0,\ b-a+1) \text{(pas de 1)} \]
De 1 à 10 : 10 tours ; de 3 à 7 : \(7-3+1=5\) tours (3, 4, 5, 6, 7) ; de 1 à 0 : aucun tour.
Lecture. Pour rend impossible l’oubli de la progression : elle est faite par l’en-tête, après chaque tour. Le corps ne modifie pas le compteur.
Tableau d’état : les 8 derniers pas.
Entrée au clavier : 4
Écrit par Écrire \(\rightarrow\)
factorielle : 24Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 4.
Lecture. Ligne 2 : f reçoit 1.
Lecture. Ligne 3 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 4 : vrai ; un tour du corps.
Lecture. Ligne 4 : f ← f × i : f passe de 1 à 1.
Lecture. Ligne 3 : Pour augmente i : 2 ; test 2 ≤ 4 : vrai ; un tour du corps.
Lecture. Ligne 4 : f ← f × i : f passe de 1 à 2.
Lecture. Ligne 3 : Pour augmente i : 3 ; test 3 ≤ 4 : vrai ; un tour du corps.
Lecture. Ligne 4 : f ← f × i : f passe de 2 à 6.
Lecture. Ligne 3 : Pour augmente i : 4 ; test 4 ≤ 4 : vrai ; un tour du corps.
Lecture. Ligne 4 : f ← f × i : f passe de 6 à 24.
Lecture. Ligne 3 : Pour augmente i : 5 ; test 5 ≤ 4 : faux ; fin du Pour ; suite à la ligne 6.
Lecture. Ligne 6 : Écrire écrit « factorielle : 24 ». Pour gère seul le compteur (initialisation, test, augmentation) : 4 tours, 5 tests, \(f=1\times2\times3\times4=24\). \(f\) part de 1, l’élément neutre de la multiplication.
Énoncé
Correction
| \(i\) | \(i\) mod \(2=0\) | \(s\) après |
|---|---|---|
| 1 | faux | 0 |
| 2 | vrai | 2 |
| 3 | faux | 2 |
| 4 | vrai | 6 |
| 5 | faux | 6 |
| 6 | vrai | 12 |
12, soit \(2+4+6\).Pour lire une note valide, il faut d’abord la lire : la condition porte sur ce que produit le corps.
{Répéter \(B\) Jusqu’à \(C\)}
Exécuter \(B\), puis évaluer la condition de sortie \(C\) : vraie, la boucle s’arrête ; fausse, \(B\) recommence. Le corps est exécuté au moins une fois.
Lecture. Répéter \(B\) Jusqu’à \(C\) équivaut à \(B\) suivi de TantQue NON \(C\) Faire \(B\).
Tableau d’état : les 6 derniers pas.
Entrée au clavier : 25 ; -3 ; 14
Écrit par Écrire \(\rightarrow\)
invalide : 25
invalide : -3
note retenue : 14Lecture. Ligne 1 : début du tour 1 de Répéter ; le corps s’exécute sans test préalable.
Lecture. Ligne 2 : Lire note ; l’entrée au clavier donne note \(=\) 25.
Lecture. Ligne 3 : test du Si, 25 < 0 OU 25 > 20 : vrai ; le bloc Alors est exécuté.
Lecture. Ligne 4 : Écrire écrit « invalide : 25 ».
Lecture. Ligne 6 : condition de sortie note ≥ 0 ET note ≤ 20, soit 25 ≥ 0 ET 25 ≤ 20 : faux ; un tour de plus.
Lecture. Ligne 1 : début du tour 2 de Répéter ; le corps s’exécute sans test préalable.
Lecture. Ligne 2 : Lire note ; l’entrée au clavier donne note \(=\) -3.
Lecture. Ligne 3 : test du Si, -3 < 0 OU -3 > 20 : vrai ; le bloc Alors est exécuté.
Lecture. Ligne 4 : Écrire écrit « invalide : -3 ».
Lecture. Ligne 6 : condition de sortie note ≥ 0 ET note ≤ 20, soit -3 ≥ 0 ET -3 ≤ 20 : faux ; un tour de plus.
Lecture. Ligne 1 : début du tour 3 de Répéter ; le corps s’exécute sans test préalable.
Lecture. Ligne 2 : Lire note ; l’entrée au clavier donne note \(=\) 14.
Lecture. Ligne 3 : test du Si, 14 < 0 OU 14 > 20 : faux ; le bloc est sauté.
Lecture. Ligne 6 : condition de sortie note ≥ 0 ET note ≤ 20, soit 14 ≥ 0 ET 14 ≤ 20 : vrai ; sortie de la boucle.
Lecture. Ligne 7 : Écrire écrit « note retenue : 14 ». Trois tours : 25 et \(-3\) font recommencer, 14 fait sortir. Le corps passe toujours avant le test : au moins une lecture.
Tableau d’état : les 6 derniers pas.
Écrit par Écrire \(\rightarrow\)
tour 1
tour 1
tour 1
tour 1
[...]Lecture. Ligne 1 : i reçoit 1.
Lecture. Ligne 2 : test i ≤ 3, soit 1 ≤ 3 : vrai ; le corps est exécuté.
Lecture. Ligne 3 : Écrire écrit « tour 1 ».
Lecture. Ligne 2 : test i ≤ 3, soit 1 ≤ 3 : vrai ; le corps est exécuté.
Lecture. Ligne 3 : Écrire écrit « tour 1 ».
Lecture. Ligne 2 : test i ≤ 3, soit 1 ≤ 3 : vrai ; le corps est exécuté.
Lecture. Ligne 3 : Écrire écrit « tour 1 ».
Lecture. Ligne 2 : test i ≤ 3, soit 1 ≤ 3 : vrai ; le corps est exécuté.
Lecture. Ligne 3 : Écrire écrit « tour 1 ». Le pas 9 a le même état que le pas 3 : \(i\) reste 1, le test reste vrai. La boucle ne s’arrête jamais (trace interrompue ici) ; la ligne 5 n’est jamais atteinte.
Tableau d’état : les 8 derniers pas.
Entrée au clavier : 4
Écrit par Écrire \(\rightarrow\)
somme : 6Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 4.
Lecture. Ligne 2 : s reçoit 0.
Lecture. Ligne 3 : i reçoit 1.
Lecture. Ligne 4 : test i < n, soit 1 < 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 0 à 1.
Lecture. Ligne 6 : i ← i + 1 : i passe de 1 à 2.
Lecture. Ligne 4 : test i < n, soit 2 < 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 1 à 3.
Lecture. Ligne 6 : i ← i + 1 : i passe de 2 à 3.
Lecture. Ligne 4 : test i < n, soit 3 < 4 : vrai ; le corps est exécuté.
Lecture. Ligne 5 : s ← s + i : s passe de 3 à 6.
Lecture. Ligne 6 : i ← i + 1 : i passe de 3 à 4.
Lecture. Ligne 4 : test i < n, soit 4 < 4 : faux ; la boucle s’arrête ; suite à la ligne 8.
Lecture. Ligne 8 : Écrire écrit « somme : 6 ». Avec < au lieu de \(\leq\), le tour \(i=n\) manque : \(s=1+2+3=6\) au lieu de 10 (diapositive de la somme). La boucle s’arrête, sans erreur, un tour trop tôt.
Quoi
Une boucle infinie ne rencontre jamais de test faux : progression oubliée, ou progression qui saute la valeur d’arrêt (\(i\leftarrow i+2\) avec TantQue \(i\neq10\) à partir de \(i=1\)). Une erreur de décalage d’une unité fait un tour de trop ou de moins (\(<\) au lieu de \(\leq\)).
Pourquoi elles passent inaperçues
L’algorithme respecte les règles d’écriture : il fait exactement ce qui est écrit, sans message d’erreur. Seule la comparaison avec une trace à la main, sur une petite entrée dont on connaît le résultat, les révèle.
Quand ça échoue encore : un réel comme compteur
En machine, les réels sont rangés en base 2 sur 64 bits : \(0{,}1\) ajouté dix fois à 0 donne \(0{,}9999999999999999\), et non 1 ; un test \(x\neq1\) ne devient jamais faux. Un compteur doit être entier ; préférer \(\leq\) ou \(<\) à \(\neq\) dans une condition d’arrêt.
Tableau d’état : les 6 derniers pas.
Écrit par Écrire \(\rightarrow\)
1 1
1 2
1 3
2 1
2 2
2 3Lecture. Ligne 1 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 2 : vrai ; un tour du corps.
Lecture. Ligne 2 : Pour donne à j sa première valeur, 1 ; test 1 ≤ 3 : vrai ; un tour du corps.
Lecture. Ligne 3 : Écrire écrit « 1 1 ».
Lecture. Ligne 2 : Pour augmente j : 2 ; test 2 ≤ 3 : vrai ; un tour du corps.
Lecture. Ligne 3 : Écrire écrit « 1 2 ».
Lecture. Ligne 2 : Pour augmente j : 3 ; test 3 ≤ 3 : vrai ; un tour du corps.
Lecture. Ligne 3 : Écrire écrit « 1 3 ».
Lecture. Ligne 2 : Pour augmente j : 4 ; test 4 ≤ 3 : faux ; fin du Pour ; retour à l’en-tête de la ligne 1.
Lecture. Ligne 1 : Pour augmente i : 2 ; test 2 ≤ 2 : vrai ; un tour du corps.
Lecture. Ligne 2 : Pour donne à j sa première valeur, 1 ; test 1 ≤ 3 : vrai ; un tour du corps.
Lecture. Ligne 3 : Écrire écrit « 2 1 ».
Lecture. Ligne 2 : Pour augmente j : 2 ; test 2 ≤ 3 : vrai ; un tour du corps.
Lecture. Ligne 3 : Écrire écrit « 2 2 ».
Lecture. Ligne 2 : Pour augmente j : 3 ; test 3 ≤ 3 : vrai ; un tour du corps.
Lecture. Ligne 3 : Écrire écrit « 2 3 ».
Lecture. Ligne 2 : Pour augmente j : 4 ; test 4 ≤ 3 : faux ; fin du Pour ; retour à l’en-tête de la ligne 1.
Lecture. Ligne 1 : Pour augmente i : 3 ; test 3 ≤ 2 : faux ; fin du Pour ; l’algorithme est terminé. Pour chaque valeur de \(i\), la boucle interne refait ses trois tours depuis \(j=1\) : \(2\times3=6\) écritures, dans l’ordre (1,1), (1,2), (1,3), (2,1), (2,2), (2,3).
Tours du corps intérieur
Pour \(i\) de 1 à \(n\), Pour \(j\) de 1 à \(m\) : \(n\times m\) tours ; Pour \(i\) de 1 à \(n\), Pour \(j\) de 1 à \(i\) : \(1+2+\dots+n=n(n+1)/2\) tours (la somme écrite à l’endroit puis à l’envers donne \(n\) colonnes de valeur \(n+1\)).
\(n=4\) ; encadrée en orange, la ligne \(i=3\) : un tour externe, pendant lequel la boucle interne fait 3 tours.
Lecture. \(n=10\) : 55 et 100 tours ; \(n=1000\) : \(500\,500\) et un million : croissance en \(n^2\).
Énoncé
Correction
| \(i\) | \(j\) de 1 à \(i\) | lignes écrites |
|---|---|---|
| 1 | 1 | 1 1 |
| 2 | 1, 2 | 2 1, 2 2 |
| 3 | 1, 2, 3 | 3 1, 3 2, 3 3 |
1 1, 2 1, 2 2, 3 1, 3 2, 3 3.2 1, 3 1, 3 2 ; pour \(i=1\), la boucle de 1 à 0 ne fait aucun tour.| boucle | test | tours au moins | quand l’utiliser |
|---|---|---|---|
| TantQue \(C\) Faire … FinTantQue | avant le corps | 0 | nombre de tours inconnu à l’entrée |
| Pour \(i\) de \(a\) à \(b\) Faire … FinPour | avant le corps | 0 | nombre de tours connu : \(\max(0,b-a+1)\) (pas de 1) |
| Répéter … Jusqu’à \(C\) | après le corps | 1 | la condition porte sur ce que produit le corps (saisie) |
À retenir
Séance 4 — Les tableaux
Un tableau range plusieurs valeurs de même type sous un seul nom, chacune repérée par un indice. Le lire, l’écrire, chercher son maximum ou sa somme, c’est parcourir ses indices par une boucle Pour : les compteurs, les accumulateurs et les bornes de cette séance s’appliquent case par case, et un décalage d’une unité devient un accès hors du tableau.
À préparer : refaire à la main les traces de la somme, du compteur et de la saisie contrôlée avec d’autres entrées.
Algorithmique — Séance 3 Dr. El Hadji Bassirou TOURÉ • DMI/FST/UCAD
Lecture. Ligne 1 : Lire
n; l’entrée au clavier donnen\(=\) 3.Lecture. Ligne 2 :
ireçoit1.Lecture. Ligne 3 : test
i ≤ n, soit1 ≤ 3: vrai ; le corps est exécuté.Lecture. Ligne 4 : Écrire écrit «
tour 1».Lecture. Ligne 5 :
i ← i + 1:ipasse de 1 à 2.Lecture. Ligne 3 : test
i ≤ n, soit2 ≤ 3: vrai ; le corps est exécuté.Lecture. Ligne 4 : Écrire écrit «
tour 2».Lecture. Ligne 5 :
i ← i + 1:ipasse de 2 à 3.Lecture. Ligne 3 : test
i ≤ n, soit3 ≤ 3: vrai ; le corps est exécuté.Lecture. Ligne 4 : Écrire écrit «
tour 3».Lecture. Ligne 5 :
i ← i + 1:ipasse de 3 à 4.Lecture. Ligne 3 : test
i ≤ n, soit4 ≤ 3: faux ; la boucle s’arrête ; suite à la ligne 7.Lecture. Ligne 7 : Écrire écrit «
fin, i = 4». Trois tours, quatre tests : le test du pas 12 (\(i=4\)) est le seul faux. Après la boucle, \(i\) vaut 4, la première valeur qui rend la condition fausse.