algo-4tt — cours d’algorithmie
iREADME.md{}05_Boucles.md

algo-4tt›05_Boucles.md

Chapitre 5

Les boucles : TANTQUE et POUR

Répéter sans réécrire

  • 5 parties
  • 5 exercices
  • lecture ≈ 10 min

objectifs

Ce que tu vas apprendre

Redemander une réponse tant qu'elle n'est pas correcte, afficher une table de multiplication, faire durer un jeu tant que la partie n'est pas finie : tout cela demande de répéter des instructions. C'est le rôle des boucles, la quatrième et dernière famille d'instructions.

  • Expliquer à quoi sert une boucle.
  • Écrire une boucle TANTQUE … FINTANTQUE et préparer sa variable avant d'entrer.
  • Contrôler une saisie avec une boucle.
  • Utiliser un compteur et un accumulateur.
  • Repérer une boucle infinie et une boucle qui ne démarre jamais.
  • Écrire une boucle POUR quand le nombre de tours est connu.

partie 1

Pourquoi des boucles ?

Un programme demande de répondre par « O » (oui) ou « N » (non). L'utilisateur se trompe et tape autre chose. Avec un SI, on peut redemander une fois… mais s'il se trompe encore ? Il faudrait un deuxième SI, un troisième… sans jamais savoir combien en prévoir.

Définition

Une boucle

Une structure qui fait exécuter plusieurs fois la même série d'instructions, tant qu'une condition le demande. On parle aussi de structure répétitive ou itérative.

À quoi servent les boucles ?

Le contrôle de saisie

Redemander tant que la réponse n'est pas valable.

Les tours de jeu

Recommencer tant que la partie n'est pas finie.

Les calculs répétés

Additionner, compter, afficher une table de multiplication.

Pour aller plus loin

Dans un tableur, tu connais déjà les variables (les cellules) et les tests (la fonction SI). Les boucles, elles, sont propres à la programmation : c'est elles qui rendent un programme vraiment dynamique.

partie 2

La boucle TANTQUE

pseudocodeLa structure
TANTQUE condition    instructionsFINTANTQUE

Le programme teste la condition. Si elle est vraie, il exécute les instructions, puis remonte et teste à nouveau. Dès que la condition est fausse, il saute après le FINTANTQUE.

fig. 5.1
avant : donner une valeurcondition ?trueinstructionson remonteet on retestefalseaprès FINTANTQUELa condition est testée AVANT chaque passage : si elle est fausse dès le départ, on n'entre jamais.
La boucle TANTQUE : on teste, on exécute, on remonte.

Attention

Pas de FAIRE

La ligne du TANTQUE ne contient que la condition : pas de FAIRE, pas de ALORS. Dans VS Code, un FAIRE ajouté casse la traduction.

Le contrôle de saisie

pseudocode
variable reponse en chaine de caracteresDEBUT    ECRIRE "Veux-tu continuer ? (O/N)"    LIRE reponse    TANTQUE reponse <> "O" ET reponse <> "N"        ECRIRE "Réponds par O ou par N :"        LIRE reponse    FINTANTQUE    ECRIRE "Merci, tu as répondu " & reponse & "."FIN

à l'écran

Veux-tu continuer ? (O/N)
peut-être
Réponds par O ou par N :
oui
Réponds par O ou par N :
N
Merci, tu as répondu N.

À retenir

Préparer la condition avant d'entrer

  • La variable testée doit avoir une valeur avant le TANTQUE : une première lecture, ou une valeur de départ.
  • À l'intérieur, une instruction doit pouvoir changer cette variable, sinon on ne sort jamais.

partie 3

Compter et accumuler

Définition

Un compteur

Une variable qui augmente de 1 à chaque tour : i <- i + 1. On lit : « i prend l'ancienne valeur de i, plus 1 ».

pseudocodeUne table de multiplication (les 5 premières lignes)
variables n, i en entierDEBUT    ECRIRE "Quelle table veux-tu ?"    LIRE n    i <- 1    TANTQUE i <= 5        ECRIRE i & " x " & n & " = " & i * n        i <- i + 1    FINTANTQUEFIN

à l'écran

Quelle table veux-tu ?
7
1 x 7 = 7
2 x 7 = 14
3 x 7 = 21
4 x 7 = 28
5 x 7 = 35

Définition

Un accumulateur

Une variable qui additionne des valeurs au fil des tours : total <- total + note. Elle commence à 0.

pseudocodeAdditionner des notes jusqu'à -1
variables note, total, nb en entierDEBUT    total <- 0    nb <- 0    ECRIRE "Note (ou -1 pour terminer) ?"    LIRE note    TANTQUE note <> -1        total <- total + note        nb <- nb + 1        ECRIRE "Note (ou -1 pour terminer) ?"        LIRE note    FINTANTQUE    ECRIRE nb & " notes, total : " & totalFIN

à l'écran

Note (ou -1 pour terminer) ?
12
Note (ou -1 pour terminer) ?
15
Note (ou -1 pour terminer) ?
9
Note (ou -1 pour terminer) ?
-1
3 notes, total : 36

Suivre une boucle à la trace

Pour la table de 7, une ligne par tour : on note la valeur de i au moment du test, le résultat du test et ce qui s'affiche.

Touri (au test)i <= 5 ?Affiché
11true1 x 7 = 7
22true2 x 7 = 14
…………
55true5 x 7 = 35
fin6falseon sort de la boucle

partie 4

Les pièges à éviter

La boucle infinie

La condition de sortie n'est jamais remplie : le programme tourne sans fin. Cause habituelle : on a oublié de modifier la variable dans la boucle.

La boucle qui ne démarre pas

La condition est fausse dès le départ : les instructions ne sont jamais exécutées, même une fois.

pseudocodeBoucle infinie : où est l'erreur ?
i <- 1TANTQUE i <= 5    ECRIRE iFINTANTQUE

i vaut 1 et ne change jamais : i <= 5 reste vrai pour toujours. Il manque i <- i + 1 dans la boucle. Dans VS Code, une boucle infinie s'arrête avec Ctrl + C dans le terminal.

pseudocodeBoucle qui ne démarre jamais
i <- 10TANTQUE i <= 5    ECRIRE i    i <- i + 1FINTANTQUE

À retenir

Avant de lancer une boucle, vérifie

  • La valeur de départ : la condition est-elle vraie au premier test ?
  • Le changement : une instruction modifie-t-elle la variable testée ?
  • La sortie : cette modification finit-elle par rendre la condition fausse ?

partie 5

La boucle POUR

Quand on sait à l'avance combien de tours faire, la boucle POUR est plus simple : elle gère elle-même le compteur. C'est un cas particulier du TANTQUE.

pseudocodeLa structure (comme dans VS Code)
POUR i <- debut à fin    instructionsPOUR SUIVANTFINPOUR
fig. 5.2
POUR i <- 1 à 5i =1+1i =2+1i =3+1i =4+1i =5Le compteur avance tout seul de 1 à chaque passage : 5 passages, de i = 1 à i = 5.
Le compteur part de la valeur de début et avance de 1 à chaque tour.
pseudocodeLa table de multiplication complète
variables n, i en entierDEBUT    ECRIRE "Quelle table veux-tu ?"    LIRE n    POUR i <- 1 à 10        ECRIRE i & " x " & n & " = " & i * n    POUR SUIVANT    FINPOURFIN

à l'écran

Quelle table veux-tu ?
3
1 x 3 = 3
2 x 3 = 6
3 x 3 = 9
4 x 3 = 12
5 x 3 = 15
6 x 3 = 18
7 x 3 = 21
8 x 3 = 24
9 x 3 = 27
10 x 3 = 30

À retenir

Les règles du POUR

  • Le compteur est déclaré comme une autre variable (entier).
  • On ne modifie jamais le compteur à l'intérieur : le POUR s'en charge.
  • Le début et la fin sont un nombre ou une variable : POUR i <- 1 à n.
SituationBoucle à choisir
Le nombre de tours est connu (10 lignes, n élèves…)POUR
On ne sait pas combien de tours (saisie, jeu, « jusqu'à -1 »)TANTQUE
Compter de 2 en 2, à rebours…TANTQUE avec i <- i + 2, i <- i - 1…

Pour aller plus loin

Sur papier, certains livres écrivent un « pas » : Pour i de 10 à 1 Pas -1. L'extension de VS Code ne le connaît pas : le POUR avance toujours de 1. Pour un autre pas, utilise un TANTQUE.

synthèse

L'essentiel à retenir

  1. 01

    Une boucle répète une série d'instructions ; c'est la quatrième famille d'instructions.

  2. 02

    TANTQUE condition … FINTANTQUE répète tant que la condition est vraie ; elle est testée avant chaque tour.

  3. 03

    La variable testée doit avoir une valeur avant la boucle, et changer dans la boucle.

  4. 04

    Le contrôle de saisie redemande tant que la réponse n'est pas valable.

  5. 05

    Un compteur augmente de 1 (i <- i + 1) ; un accumulateur additionne (total <- total + note), en partant de 0.

  6. 06

    Pièges : la boucle infinie (rien ne change) et la boucle qui ne démarre jamais (fausse dès le départ).

  7. 07

    POUR i <- 1 à n … POUR SUIVANT … FINPOUR quand le nombre de tours est connu ; sinon TANTQUE.

Le lexique

Boucle
Structure qui répète des instructions (TANTQUE, POUR).
Itération
Un tour de boucle.
Contrôle de saisie
Boucle qui redemande une valeur tant qu'elle n'est pas valable.
Compteur
Variable qui augmente de 1 à chaque tour.
Accumulateur
Variable qui additionne des valeurs au fil des tours.
Boucle infinie
Boucle dont la condition reste toujours vraie : elle ne s'arrête jamais.
Valeur sentinelle
Valeur spéciale qui arrête la saisie, comme -1.

Je fais le point

exercices

Teste tes connaissances

Réponds sans regarder le cours, puis vérifie. Rien n'est envoyé ni noté : recommence autant de fois que tu veux.

01

Les boucles

Clique sur la bonne réponse.

Q1 Quand la condition d'un TANTQUE est-elle testée ?

Q2 Quelle boucle choisir pour afficher les nombres de 1 à 100 ?

Q3 Quelle boucle choisir pour redemander un mot de passe jusqu'à ce qu'il soit correct ?

Q4 Que vaut un accumulateur avant la boucle, en général ?

02

Le tableau de trace d'une boucle

Suis la boucle tour par tour.

pseudocode
variables i, total en entierDEBUT    total <- 0    i <- 1    TANTQUE i <= 4        total <- total + i        i <- i + 1    FINTANTQUE    ECRIRE totalFIN

à l'écran

10
Touri (au test)total (après le tour)
1
2
3
4
fin

03

Les pièges

Vrai ou faux ? Clique pour répondre.

Une boucle TANTQUE s'exécute toujours au moins une fois.

Oublier i <- i + 1 dans une boucle TANTQUE i <= 10 provoque une boucle infinie.

On peut écrire TANTQUE i <= 10 FAIRE dans VS Code.

Dans un POUR, on ne modifie pas le compteur soi-même.

04

Corrige la boucle

Cet algorithme devrait afficher un compte à rebours de 10 à 1.

pseudocode
variable compte en entierDEBUT    compte <- 10    TANTQUE compte > 0        ECRIRE compte    FINTANTQUE    ECRIRE "Décollage !"FIN

Q1 Que se passe-t-il quand on lance cet algorithme ?

Voir une réponse attendue

Une boucle infinie : compte vaut toujours 10, donc compte > 0 reste vrai.

Q2 Quelle instruction faut-il ajouter, et où ?

Voir une réponse attendue

compte <- compte - 1 dans la boucle, après le ECRIRE.

05

À toi de boucler

Écris l'algorithme complet : déclarations, DEBUT, instructions, FIN.

Q1 Demande une note entre 0 et 20 ; tant qu'elle n'est pas dans cet intervalle, redemande-la. Affiche ensuite « Note enregistrée ».

exemple d'écran

Note sur 20 ?
25
Erreur : entre une note entre 0 et 20.
14
Note enregistrée : 14
Voir une solution
une solution
variable note en entierDEBUT    ECRIRE "Note sur 20 ?"    LIRE note    TANTQUE note < 0 OU note > 20        ECRIRE "Erreur : entre une note entre 0 et 20."        LIRE note    FINTANTQUE    ECRIRE "Note enregistrée : " & noteFIN

Q2 Demande combien de nombres l'utilisateur veut additionner, puis demande-les un par un avec une boucle POUR et affiche leur somme.

exemple d'écran

Combien de nombres ?
3
Nombre 1 ?
4
Nombre 2 ?
10
Nombre 3 ?
6
Somme : 20
Voir une solution
une solution
variables n, i, nombre, somme en entierDEBUT    ECRIRE "Combien de nombres ?"    LIRE n    somme <- 0    POUR i <- 1 à n        ECRIRE "Nombre " & i & " ?"        LIRE nombre        somme <- somme + nombre    POUR SUIVANT    FINPOUR    ECRIRE "Somme : " & sommeFIN