Boucles Imbriquées pour Données 2D

Introduction

Aujourd'hui, nous allons franchir une nouvelle étape en répondant à la question : "que se passe-t-il si l'on a besoin d'une boucle à l'intérieur d'une autre boucle ?". Cette leçon est consacrée aux boucles imbriquées.

L'objectif est d'apprendre à les utiliser pour traiter des données à deux dimensions. L'exemple principal que nous explorerons est l'affichage des tables de multiplication, un cas d'école parfait pour comprendre ce concept. Maîtriser les boucles imbriquées est fondamental, car cela ouvre la voie au traitement de structures plus complexes comme des grilles, des tableaux à deux dimensions ou même des images, une compétence essentielle pour résoudre des problèmes plus avancés.

1. Comprendre les Boucles Imbriquées

Une structure de boucles imbriquées, c'est tout simplement une boucle qui se trouve à l'intérieur du bloc d'instructions d'une autre boucle.

• La boucle extérieure est appelée boucle externe.
• La boucle intérieure est appelée boucle interne.

Le principe de fonctionnement est simple mais crucial à bien visualiser : pour chaque tour de la boucle externe, la boucle interne s'exécute dans son intégralité.

On peut faire une analogie avec une horloge :

• La trotteuse (secondes) fait un tour complet (la boucle interne).
• Cela ne se produit qu'une seule fois pour chaque avancée d'un cran de l'aiguille des minutes (un tour de la boucle externe).

L'organigramme ci-dessous illustre cette structure. Observez bien comment le bloc entier de la "boucle interne" (avec sa propre condition, ses instructions et sa mise à jour) est situé à l'intérieur du bloc de la "boucle externe".

2. Application : Afficher les Tables de Multiplication

L'exemple le plus classique pour illustrer les boucles imbriquées est l'affichage des tables de multiplication de 1 à 10. Réfléchissons à la logique :

1. Nous devons traiter chaque table, l'une après l'autre : la table de 1, puis la table de 2, jusqu'à la table de 10. Une première boucle est nécessaire pour "parcourir" les tables. Ce sera notre boucle externe.
2. Pour chaque table, nous devons afficher 10 lignes de calcul (par exemple, pour la table de 7, il faut afficher 7x1, 7x2, ..., 7x10). Une seconde boucle est donc nécessaire pour "parcourir" les multiplications de 1 à 10. Ce sera notre boucle interne.

Le document suivant décompose parfaitement cette logique.

En suivant cette logique, voici à quoi ressemble l'algorithme complet en pseudo-code. J'ai utilisé des noms de variables clairs (table et multiplicateur) pour que leur rôle soit évident.

Algorithme TablesDeMultiplication

Variables
  table : Entier        // Le numéro de la table à afficher (1, 2, 3...)
  multiplicateur : Entier // Le nombre par lequel on multiplie (1, 2, 3...)

Début
  // Boucle externe : parcourt les tables de 1 à 10
  Pour table allant de 1 à 10 Faire
  
    // Affichage de l'en-tête pour la table en cours
    Afficher "--- Table de " + table + " ---"
    
    // Boucle interne : parcourt les multiplicateurs de 1 à 10
    Pour multiplicateur allant de 1 à 10 Faire
      // On calcule et on affiche le résultat
      resultat ← table * multiplicateur
      Afficher table + " x " + multiplicateur + " = " + resultat
    FinPour
    
    // On ajoute une ligne vide pour séparer les tables
    Afficher "" 
    
  FinPour
Fin

Traçage manuel pour bien comprendre :

• table = 1 (1er tour de la boucle externe)
  • Affiche "--- Table de 1 ---"
  • La boucle interne commence :
    • multiplicateur = 1 -> Affiche "1 x 1 = 1"
    • multiplicateur = 2 -> Affiche "1 x 2 = 2"
    • ...
    • multiplicateur = 10 -> Affiche "1 x 10 = 10"
  • La boucle interne est terminée.
• table = 2 (2ème tour de la boucle externe)
  • Affiche "--- Table de 2 ---"
  • La boucle interne recommence depuis le début :
    • multiplicateur = 1 -> Affiche "2 x 1 = 2"
    • multiplicateur = 2 -> Affiche "2 x 2 = 4"
    • ...
    • multiplicateur = 10 -> Affiche "2 x 10 = 20"
  • La boucle interne est terminée.
• ... et ainsi de suite jusqu'à table = 10.

3. Généralisation : Traiter des Données à Deux Dimensions

Les tables de multiplication sont en réalité une grille d'informations, une structure à deux dimensions. Les boucles imbriquées sont l'outil standard pour parcourir de telles structures.

Par convention :

• La boucle externe parcourt les lignes.
• La boucle interne parcourt les colonnes de chaque ligne.

Pour visualiser cela, imaginons que nous voulions dessiner un rectangle de * de 5 lignes et 10 colonnes.

Algorithme DessinerRectangle

Variables
  ligne : Entier
  colonne : Entier
  
Début
  // Boucle externe pour les lignes
  Pour ligne allant de 1 à 5 Faire
    
    // Boucle interne pour les colonnes
    Pour colonne allant de 1 à 10 Faire
      // On affiche une étoile SANS passer à la ligne suivante
      Afficher_sur_la_meme_ligne "*" 
    FinPour
    
    // Une fois toutes les colonnes de la ligne dessinées, 
    // on passe à la ligne suivante.
    Afficher_saut_de_ligne
    
  FinPour
Fin

Le résultat serait :

**********
**********
**********
**********
**********

Cette logique "ligne par ligne, puis colonne par colonne" est fondamentale et vous la retrouverez très souvent.

4. Mise en Pratique

Votre préférence allant à la pratique, mettons en application ce que nous venons de voir. L'exercice consiste à reprendre notre table de multiplication, mais en l'affichant sous forme de grille, comme dans une feuille de calcul.

Exercice : Table de multiplication formatée en grille

Écrivez un algorithme qui affiche une table de multiplication de 1 à 10 sous la forme d'une grille bien alignée. Le résultat attendu doit ressembler à ceci :

   1   2   3   4   5   6   7   8   9  10
   2   4   6   8  10  12  14  16  18  20
   3   6   9  12  15  18  21  24  27  30
   ... (et ainsi de suite)
  10  20  30  40  50  60  70  80  90 100

Indices :

1. Vous aurez besoin de deux boucles imbriquées (Pour...Faire).
2. La boucle externe gère les lignes (la table de 1, de 2, etc.).
3. La boucle interne gère les colonnes (le calcul ligne * colonne pour chaque valeur de la ligne).
4. Utilisez Afficher_sur_la_meme_ligne pour afficher tous les résultats d'une même ligne.
5. Utilisez Afficher_saut_de_ligne après la fin de la boucle interne pour passer à la ligne suivante.

Algorithme GrilleMultiplication

Variables
  ligne : Entier
  colonne : Entier
  resultat : Entier

Début
  // Boucle externe : pour chaque ligne de 1 à 10
  Pour ligne allant de 1 à 10 Faire
    
    // Boucle interne : pour chaque colonne de 1 à 10
    Pour colonne allant de 1 à 10 Faire
      resultat ← ligne * colonne
      
      // Affiche le résultat suivi d'un espace pour l'alignement
      Afficher_sur_la_meme_ligne resultat + "  " 
    FinPour
    
    // La ligne est finie, on passe à la suivante
    Afficher_saut_de_ligne
    
  FinPour
Fin

Conclusion

Félicitations ! Vous avez ajouté une technique algorithmique très importante à votre répertoire.

Points clés à retenir :

• Les boucles imbriquées sont des boucles contenues dans d'autres boucles.
• La règle d'or : la boucle interne s'exécute en entier pour chaque tour de la boucle externe.
• Elles sont la méthode standard pour parcourir des données à deux dimensions, comme des grilles ou des tables, en pensant en termes de lignes (boucle externe) et de colonnes (boucle interne).
• L'affichage des tables de multiplication est l'exemple parfait pour illustrer et comprendre leur fonctionnement.

Et après ?

Maintenant que nous savons construire des boucles simples et complexes, il est temps de s'intéresser à un problème très courant qui peut survenir : que se passe-t-il quand une boucle ne s'arrête jamais ? Dans la prochaine leçon, nous aborderons les boucles infinies, comment les identifier et, surtout, comment les corriger. C'est une étape cruciale pour écrire des programmes robustes et fiables.