⌂ Algorigrammes
Fiche 7 sur 13

Répéter tant que

La boucle : une flèche qui remonte pour refaire plusieurs fois la même chose.

Après cette fiche, vous saurez :

1Pourquoi répéter ?

Pour afficher « Tour 1 », « Tour 2 »... jusqu'à « Tour 100 », on ne va pas dessiner cent trapèzes. On utilise une boucle : un morceau du dessin qu'on repasse plusieurs fois.

Une boucle ne possède pas de forme à elle. Elle se dessine avec le losange de la fiche 5 et une flèche qui remonte.

2La boucle « tant que »

Début int compteur = 1 compteur <= 5 "Tour {compteur}" compteur++ "Terminé" Fin oui non

Suivez le chemin avec le doigt :

  1. On déclare compteur = 1 (le point de départ).
  2. Le losange demande : « tant que compteur <= 5 ? »
  3. Si oui (la condition est respectée), le chemin part à droite et on entre dans la boucle : on affiche, on augmente le compteur, puis la flèche remonte au losange, par la droite.
  4. Si non (la condition n'est plus respectée), le chemin descend : on sort de la boucle et on continue avec la suite.

Dans tous les algorigrammes du cours, la règle est la même : « oui » part à droite, « non » part à gauche ou vers le bas.

Chaque passage dans la boucle s'appelle un tour. Le même programme en C# :

int compteur = 1;

while (compteur <= 5)
{
    Console.WriteLine($"Tour {compteur}");
    compteur++;
}
Console.WriteLine("Terminé");
Ce que l'ordinateur affiche
Tour 1
Tour 2
Tour 3
Tour 4
Tour 5
Terminé

3Les trois étapes d'une boucle

Une boucle qui compte repose toujours sur trois éléments. Si l'un manque, la boucle ne fonctionne pas.

ÉtapeDans l'exempleOù ?
1. Initialiser le compteurint compteur = 1dans le rectangle de déclaration, avant la boucle
2. Tester la conditioncompteur <= 5dans le losange
3. Modifier le compteurcompteur++dans la boucle, avant la flèche qui remonte

Pour vérifier une boucle, on la déroule avec une table de suivi, avec une ligne à chaque passage dans le losange :

Passagecompteur
test n°11
test n°22
test n°33
test n°44
test n°55
test n°66

À la dernière ligne, compteur vaut 6 : la condition est fausse, on sort. Le programme a donc fait 5 tours, pas 6.

4Le danger : la boucle infinie

Que se passe-t-il si l'on oublie de modifier le compteur ?

Début int compteur = 1 compteur <= 5 "Tour {compteur}" "Terminé" Fin oui non

Le compteur reste à 1 pour toujours. La condition compteur <= 5 est toujours vraie, la flèche remonte sans arrêt : le programme affiche « Tour 1 » à l'infini, et ne s'arrête jamais. C'est une boucle infinie.

Attention

Avant de valider une boucle, posez-vous la question :

« Qu'est-ce qui, dans la boucle, va finir par rendre la condition fausse ? »

Si vous n'avez pas de réponse, c'est qu'il manque quelque chose.

5Le test est avant : parfois aucun tour

Dans une boucle « tant que », le test se fait avant d'entrer. Si la condition est fausse dès le début, on ne fait aucun tour. Avec compteur = 10 au départ, la boucle de l'exemple n'afficherait rien du tout, et passerait directement à « Terminé ».

6Compter à l'envers, et par pas de 2

Le compteur n'est pas obligé d'augmenter de 1. Voici un compte à rebours :

Début int n = 5 n >= 1 "{n}" n-- "Décollage !" Fin oui non
Ce que l'ordinateur affiche
5
4
3
2
1
Décollage !

Le départ est 5, la condition n >= 1 et la modification n--. Les trois étapes sont toujours là, mais à l'envers.

7Cumuler dans une boucle

Une boucle sert souvent à ajouter des valeurs. Voici la somme des nombres de 1 à 5 :

Début int i = 1 int somme = 0 i <= 5 somme += i i++ "La somme est {somme}" Fin oui non
Passageisomme
test n°110
test n°221
test n°333
test n°446
test n°5510
test n°6615

La somme part de 0 et, à chaque tour, on y ajoute i. À la fin, elle vaut 15 (1 + 2 + 3 + 4 + 5).

Attention

« < » ou « <= » ?

Pour répéter 7 fois en partant de 1, la condition est jour <= 7. Avec jour < 7, on ne ferait que 6 tours. Vérifiez toujours avec la table de suivi que le dernier tour est bien celui voulu.

À retenir

→Exercices

1La table de 7Recopier

Reproduisez cet algorigramme. Que va-t-il afficher à la première et à la dernière ligne ?

Début int i = 1 int resultat i <= 10 resultat = 7 * i "7 x {i} = {resultat}" i++ Fin oui non

Solution

Début int i = 1 int resultat i <= 10 resultat = 7 * i "7 x {i} = {resultat}" i++ Fin oui non
Ce que l'ordinateur affiche
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70

La première ligne est 7 x 1 = 7 et la dernière 7 x 10 = 70 : le compteur i va de 1 à 10 (la boucle s'arrête quand il vaut 11).

2Le compte à reboursModifier

Voici une boucle qui compte de 1 à 5.

Début int compteur = 1 compteur <= 5 "Tour {compteur}" compteur++ "Terminé" Fin oui non

Transformez-la en compte à rebours qui affiche 5, 4, 3, 2, 1, puis « Décollage ! ». Quels éléments devez-vous changer ?

Solution

Il y a trois changements, ceux des trois étapes de la boucle :

  1. le départ : 5 au lieu de 1 ;
  2. la condition : n >= 1 au lieu de <= 5 ;
  3. la modification : n-- au lieu de ++.
Début int n = 5 n >= 1 "{n}" n-- "Décollage !" Fin oui non
Ce que l'ordinateur affiche
5
4
3
2
1
Décollage !
3Les nombres pairsCréer

Dessinez l'algorigramme qui affiche tous les nombres pairs de 2 à 20 : 2, 4, 6... 20.

Indice : le compteur n'avance pas de 1 à chaque tour.

Solution

Le compteur démarre à 2 et avance de 2 à chaque tour, avec += 2 :

Début int nombre = 2 nombre <= 20 "{nombre}" nombre += 2 Fin oui non
Ce que l'ordinateur affiche
2
4
6
8
10
12
14
16
18
20

La condition est nombre <= 20 (et non < 20) pour que 20 soit bien affiché. Dix tours en tout.

4La somme des 10 premiers nombres (syllabus P3·1)Créer

Dessinez l'algorigramme qui affiche la somme des 10 premiers nombres (de 0 à 10).

L'utilisateur ne doit pas entrer les nombres : c'est le programme qui les fait défiler tout seul.

Solution

Le compteur i défile de 0 à 10, et la somme part de 0. À chaque tour, on ajoute i à la somme :

Début int i = 0 int somme = 0 i <= 10 somme += i i++ "La somme est : " , somme Fin oui non
Passageisomme
test n°100
test n°210
test n°321
test n°433
test n°546
test n°6510
test n°7615
test n°8721
test n°9828
test n°10936
test n°111045
test n°121155

La somme vaut 55. Comme on part de 0, il y a onze passages dans la boucle (de 0 à 10 compris), mais le 0 n'ajoute rien. Partir de 1 donnerait le même résultat avec un tour de moins.

5Les carrés de dix nombres (syllabus P3·2)Créer

Dessinez l'algorigramme qui lit 10 nombres au clavier, l'un après l'autre, et affiche le carré de chacun.

Solution

Cette fois, l'utilisateur tape les nombres : la boucle compte les 10 tours, et chaque tour contient une question (trapèze), une saisie (parallélogramme), un calcul (rectangle) et un affichage. Le carré d'un nombre est ce nombre multiplié par lui-même.

Début int i = 1 int nombre int carre i <= 10 "Nombre {i} :" nombre carre = nombre * nombre "Son carré est : " , carre i++ Fin oui non
Ce que l'ordinateur affiche
Nombre 1 :
Son carré est : 1
Nombre 2 :
Son carré est : 4
Nombre 3 :
Son carré est : 9
Nombre 4 :
Son carré est : 16
Nombre 5 :
Son carré est : 25
Nombre 6 :
Son carré est : 36
Nombre 7 :
Son carré est : 49
Nombre 8 :
Son carré est : 64
Nombre 9 :
Son carré est : 81
Nombre 10 :
Son carré est : 100

Un nombre négatif a un carré positif : -10 * -10 = 100.

Je sais faire

Une case qui coince ? Relisez la partie concernée avant de passer à la fiche suivante.

← Fiche 6 Fiche 8 : La saisie contrôlée →