⌂ Algorigrammes
Fiche 10 sur 13

Les boucles imbriquées

Une boucle à l'intérieur d'une autre : refaire, à chaque tour, une boucle complète.

Après cette fiche, vous saurez :

1Une boucle dans une boucle

Jusqu'ici, nos boucles se suivaient ou s'utilisaient seules. Mais il arrive qu'à chaque tour d'une boucle, il faille refaire une autre boucle complète. On dit que les boucles sont imbriquées (incluses l'une dans l'autre).

Un exemple de la vie courante : une horloge. À chaque heure qui passe (boucle extérieure), les 60 minutes défilent (boucle intérieure). Les minutes recommencent à 0 à chaque nouvelle heure.

2Le schéma

Voici deux boucles à test en fin (celles de votre syllabus), l'une dans l'autre. La boucle 2 est entièrement contenue dans le corps de la boucle 1 :

Début traitement 1 traitement 2 condition boucle 2 condition boucle 1 Fin oui non oui non

Lisez-le dans l'ordre :

  1. le traitement 1 s'exécute ;
  2. puis la boucle 2 tourne jusqu'au bout (le traitement 2 se répète tant que la condition 2 est vraie) ;
  3. quand la boucle 2 est finie, on arrive au test de la boucle 1 : si elle doit continuer, on recommence tout (y compris la boucle 2).

Attention

Deux boucles imbriquées ne peuvent pas se croiser.

La boucle intérieure doit être entièrement à l'intérieur de la boucle extérieure : elle commence après le début de l'extérieure et se termine avant sa fin. Sur le dessin, les deux flèches qui remontent ne se coupent jamais.

3Un exemple : les tables de multiplication

On veut afficher les tables de multiplication de 1 à 3, chacune de ×1 à ×4. Pour chaque table (boucle extérieure), on parcourt les multiplicateurs de 1 à 4 (boucle intérieure).

Début int table = 1 int i int resultat table <= 3 i = 1 i <= 4 resultat = table * i "{table} x {i} = {resultat}" i++ table++ Fin oui oui non non

Le même programme en C# :

int table = 1;
int i;
int resultat;

while (table <= 3)
{
    i = 1;                              // la boucle intérieure repart de 1 à chaque table
    while (i <= 4)
    {
        resultat = table * i;
        Console.WriteLine($"{table} x {i} = {resultat}");
        i++;
    }
    table++;
}
Ce que l'ordinateur affiche
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12

Il y a 3 × 4 = 12 lignes : la boucle intérieure fait 4 tours, et elle est refaite pour chacun des 3 tours de la boucle extérieure.

4Dérouler deux boucles

Avec deux compteurs, la table de suivi garde les deux colonnes. Voici les tables de 1 à 2, de ×1 à ×3 (une ligne à chaque passage dans le losange intérieur) :

Passagetableiresultat

Observez comment i repart de 1 quand table passe de 1 à 2 : c'est l'instruction i = 1 de la boucle extérieure qui le remet à sa valeur de départ.

5Le piège : oublier de réinitialiser

Que se passe-t-il si l'on oublie de remettre i à 1 à chaque tour de la boucle extérieure ?

Début int table = 1 int i = 1 int resultat table <= 3 i <= 4 resultat = table * i "{table} x {i} = {resultat}" i++ table++ Fin oui oui non non
Ce que l'ordinateur affiche
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4

Après la table de 1, i vaut 5. Pour la table de 2, la condition i <= 4 est déjà fausse : la boucle intérieure ne tourne plus du tout. La boucle extérieure, elle, fait ses trois tours, mais pour rien.

À retenir

Le compteur d'une boucle intérieure doit être remis à sa valeur de départ à chaque tour de la boucle extérieure, à l'intérieur de celle-ci (et non dans le rectangle de déclaration du début).

6Cumuler avec deux boucles : que remettre à zéro ?

Une boucle imbriquée sert souvent à cumuler « par groupe » : les ventes de chaque jour (4 ventes par jour, sur 3 jours), avec un total par jour et un total général.

Début int jour = 1 int vente double montant double total_jour double total_general = 0 jour <= 3 total_jour = 0 vente = 1 vente <= 4 "Jour {jour}, vente {vente} (montant) :" montant total_jour += montant vente++ "Total du jour {jour} : {total_jour}" total_general += total_jour jour++ "Total général : {total_general}" Fin oui oui non non
Ce que l'ordinateur affiche
Jour 1, vente 1 (montant) :
Jour 1, vente 2 (montant) :
Jour 1, vente 3 (montant) :
Jour 1, vente 4 (montant) :
Total du jour 1 : 100
Jour 2, vente 1 (montant) :
Jour 2, vente 2 (montant) :
Jour 2, vente 3 (montant) :
Jour 2, vente 4 (montant) :
Total du jour 2 : 4
Jour 3, vente 1 (montant) :
Jour 3, vente 2 (montant) :
Jour 3, vente 3 (montant) :
Jour 3, vente 4 (montant) :
Total du jour 3 : 20
Total général : 124

Deux totaux, deux comportements :

VariableDoit-elle être remise à 0 ?Pourquoi
total_jouroui, à chaque tour extérieurelle ne doit contenir que les ventes du jour en cours
total_generalnon, jamaiselle garde l'addition de tous les jours
vente (le compteur intérieur)oui, remis à 1 à chaque jourpour compter de nouveau les 4 ventes

Attention

Pour chaque variable, posez-vous la question : « a-t-elle besoin de repartir de zéro à chaque tour extérieur ? » Si oui, la remise à zéro se place au début du corps de la boucle extérieure.

À retenir

→Exercices

1Les tables de 1 à 3Recopier

Reproduisez cet algorigramme. Combien de lignes affiche-t-il ? Quelles sont la première et la dernière ?

Début int table = 1 int i int resultat table <= 3 i = 1 i <= 4 resultat = table * i "{table} x {i} = {resultat}" i++ table++ Fin oui oui non non

Solution

Début int table = 1 int i int resultat table <= 3 i = 1 i <= 4 resultat = table * i "{table} x {i} = {resultat}" i++ table++ Fin oui oui non non
Ce que l'ordinateur affiche
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12

Douze lignes (3 tables × 4 multiplicateurs) : la première est 1 x 1 = 1, la dernière 3 x 4 = 12. Vérifiez que i = 1 se trouve bien dans la boucle extérieure.

2Les tables de 1 à 5, jusqu'à ×10Modifier

Modifiez l'algorigramme de l'exercice 1 pour afficher les tables de 1 à 5, chacune de ×1 à ×10. Combien de lignes obtiendra-t-on ?

Solution

Seules deux conditions changent : table <= 5 pour la boucle extérieure et i <= 10 pour la boucle intérieure. La structure reste identique.

Début int table = 1 int i int resultat table <= 5 i = 1 i <= 10 resultat = table * i "{table} x {i} = {resultat}" i++ table++ Fin oui oui non non
Ce que l'ordinateur affiche
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
...
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

On obtient 5 × 10 = 50 lignes.

3La moyenne de chaque élèveCréer

Trois élèves ont chacun quatre notes. Dessinez l'algorigramme qui demande les notes élève par élève, affiche la moyenne de chaque élève, puis la meilleure moyenne de la classe.

Indice : que faut-il remettre à zéro pour chaque nouvel élève ?

Solution

La somme des notes et le compteur de notes repartent à zéro pour chaque élève ; la meilleure moyenne, elle, se garde d'un élève à l'autre.

Début int eleve = 1 int i double note double somme double moyenne double meilleure = 0 eleve <= 3 somme = 0 i = 1 i <= 4 "Élève {eleve}, note {i} :" note somme += note i++ moyenne = somme / 4 "Moyenne de l'élève {eleve} : {moyenne}" moyenne > meilleure meilleure = moyenne eleve++ "Meilleure moyenne : {meilleure}" Fin oui oui non oui non non
Ce que l'ordinateur affiche
Élève 1, note 1 :
Élève 1, note 2 :
Élève 1, note 3 :
Élève 1, note 4 :
Moyenne de l'élève 1 : 13
Élève 2, note 1 :
Élève 2, note 2 :
Élève 2, note 3 :
Élève 2, note 4 :
Moyenne de l'élève 2 : 8
Élève 3, note 1 :
Élève 3, note 2 :
Élève 3, note 3 :
Élève 3, note 4 :
Moyenne de l'élève 3 : 19
Meilleure moyenne : 19

Moyennes : (10 + 12 + 14 + 16) / 4 = 13, puis 8, puis 19. La meilleure est 19.

4Les couples de somme paireCréer

Les nombres a et b prennent chacun les valeurs 1, 2 et 3. Dessinez l'algorigramme qui parcourt tous les couples (a, b) et affiche combien ont une somme paire.

Indice : une boucle sur a contenant une boucle sur b, avec un compteur dans un Si (fiche 9).

Solution

Il y a 3 × 3 = 9 couples. Pour chacun, un losange teste si (a + b) est pair (reste de la division par 2 égal à 0, fiche 4), et un compteur s'incrémente :

Début int a = 1 int b int nb = 0 a <= 3 b = 1 b <= 3 (a + b) % 2 == 0 nb++ b++ a++ "Nombre de couples : " , nb Fin oui oui oui non non non
aba + bSomme paire ?
112oui
123non
134oui
213non
224oui
235non
314oui
325non
336oui
Ce que l'ordinateur affiche
Nombre de couples : 5

Cinq couples sur neuf ont une somme paire. N'oubliez pas b = 1 au début de chaque tour de la boucle sur a.

Je sais faire

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

← Fiche 9 Fiche 11 : La plus longue série →