Boucles imbriquées

Fait partie de la section Fondamentaux du Journey GO de Coddy. Leçon 49 sur 109.

Les boucles imbriquées sont des boucles placées à l’intérieur d’une autre boucle. La boucle interne s’exécute entièrement à chaque itération de la boucle externe.

Créons une table de multiplication pour les nombres de 1 à 3 à l’aide de boucles imbriquées :

rows := 3
cols := 3
for i := 1; i <= rows; i++ {
    for j := 1; j <= cols; j++ {
        fmt.Printf("%d×%d=%d\t", i, j, i*j)
    }
    fmt.Println()
}

Après avoir exécuté ce code, nous obtenons une table de multiplication où chaque ligne représente une valeur de la variable de la boucle externe (i) multipliée par toutes les valeurs de la variable de la boucle interne (j). Le résultat s’affichera à l’écran :

1×1=1   1×2=2   1×3=3   
2×1=2   2×2=4   2×3=6   
3×1=3   3×2=6   3×3=9

Comprenons comment cela fonctionne étape par étape :

Tout d’abord, la boucle externe définit i=1 et la boucle interne s’exécute complètement :

i=1, j=1: prints "1×1=1"
i=1, j=2: prints "1×2=2"
i=1, j=3: prints "1×3=3"

Une fois la boucle interne terminée, nous affichons une nouvelle ligne avec fmt.Println().

Ensuite, la boucle externe définit i=2 et la boucle interne recommence, avec j qui repart de 1 :

i=2, j=1: prints "2×1=2"
i=2, j=2: prints "2×2=4"
i=2, j=3: prints "2×3=6"

Enfin, la boucle externe définit i=3 et la boucle interne s’exécute une dernière fois :

i=3, j=1: prints "3×1=3"
i=3, j=2: prints "3×2=6"
i=3, j=3: prints "3×3=9"

Chaque boucle a son propre compteur (i et j), et rows et cols ne changent jamais : ils indiquent seulement aux boucles quand s’arrêter. Ce modèle est très utile pour travailler avec des tableaux de données ou créer des structures en grille.

Défi

Débutant

Dans ce défi, tu vas t’entraîner à utiliser des boucles imbriquées pour afficher un motif simple. La boucle externe parcourra les lignes, et la boucle interne parcourra les colonnes pour créer une petite grille de caractères.

Complète les boucles imbriquées pour afficher une grille de 3x3 astérisques (*). Chaque astérisque doit être suivi d’une espace, chaque ligne doit donc ressembler à * * * (avec une espace finale). Le résultat attendu est :

* * * 
* * * 
* * *

Utilise un nouveau compteur pour chaque boucle (par exemple i pour les lignes et j pour les astérisques d’une ligne) et compare-le à rows ou à columns. Ne modifie pas rows et columns eux-mêmes : chaque ligne a besoin de columns à nouveau.

Essayez vous-même

package main

import "fmt"

func main() {
	// Nombre de lignes et de colonnes dans notre grille
	rows := 3
	columns := 3
	
	// TODO: Créer une boucle imbriquée pour afficher une grille d’astérisques (*)
	// La boucle externe doit parcourir les lignes
	// La boucle interne doit parcourir les colonnes
	for i := 0; i < rows; i++ {
		// Ajoutez ici votre boucle interne pour afficher des astérisques dans chaque colonne
		
		// Ceci affiche un saut de ligne après chaque ligne
		fmt.Println()
	}
}