Boucles imbriquées en C : Un guide complet pour les débutants

Salut à toi, futur magicien du codage ! Aujourd'hui, nous plongeons dans le monde magique des boucles imbriquées en C. Ne t'inquiète pas si tu es nouveau dans la programmation - je serai ton guide amical pour cette aventure passionnante. À la fin de ce tutoriel, tu seras capable deimbriquer des boucles comme un pro !

Quelles sont les boucles imbriquées ?

Avant de sauter dans le grand bain, penchons-nous sur les bases. Imagine que tu organises ton tiroir à chaussettes. Tu as des chaussettes de différentes couleurs, et chaque couleur a plusieurs paires. Pour les trier, tu pourrais passer par chaque couleur (boucle externe) et puis compter et appairer chaque chaussette de cette couleur (boucle interne). C'est essentiellement ce que font les boucles imbriquées en programmation !

Une boucle imbriquée est simplement une boucle à l'intérieur d'une autre boucle. La boucle interne s'exécute complètement pour chaque itération de la boucle externe. C'est comme ces poupées russes - tu en ouvres une, et il y en a une autre à l'intérieur !

Boucles imbriquées For

Commençons par le type de boucles le plus commun : les boucles imbriquées for. Voici un exemple simple :

#include <stdio.h>

int main() {
int i, j;
for (i = 1; i <= 3; i++) {
for (j = 1; j <= 3; j++) {
printf("(%d, %d) ", i, j);
}
printf("\n");
}
return 0;
}

Ce code affichera :

(1, 1) (1, 2) (1, 3)
(2, 1) (2, 2) (2, 3)
(3, 1) (3, 2) (3, 3)

Reprenons :

1. La boucle externe (i) s'exécute 3 fois.
2. Pour chaque itération de la boucle externe, la boucle interne (j) s'exécute 3 fois.
3. Nous affichons les valeurs de i et j chaque fois que la boucle interne s'exécute.
4. Après que la boucle interne se termine, nous affichons un caractère de nouvelle ligne (\n).

C'est comme une danse : la boucle externe conduit, et la boucle interne suit, tournant trois fois pour chaque pas de la boucle externe !

Un exemple plus pratique

Maintenant, utilisons des boucles imbriquées pour créer une table de multiplication :

#include <stdio.h>

int main() {
int i, j;
printf("   ");
for (i = 1; i <= 10; i++) {
printf("%4d", i);
}
printf("\n   -------------------------------------\n");
for (i = 1; i <= 10; i++) {
printf("%2d |", i);
for (j = 1; j <= 10; j++) {
printf("%4d", i * j);
}
printf("\n");
}
return 0;
}

Ce code crée une belle table de multiplication 10x10. La boucle externe représente les lignes, et la boucle interne représente les colonnes. Nous multiplions le numéro de ligne par le numéro de colonne pour obtenir la valeur de chaque cellule.

Imbriquer une boucle While à l'intérieur d'une boucle For

Qui a dit qu'on ne pouvait pas mixer et matcher ? Essayons d'imbriquer une boucle while à l'intérieur d'une boucle for :

#include <stdio.h>

int main() {
int i, j;
for (i = 1; i <= 5; i++) {
j = 1;
while (j <= i) {
printf("* ");
j++;
}
printf("\n");
}
return 0;
}

Ce code affiche un triangle rectangle d'étoiles :

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

Ici, la boucle for contrôle le nombre de lignes, tandis que la boucle while imprime les étoiles dans chaque ligne. C'est comme construire une pyramide - tu ajoutes plus de blocs à mesure que tu montes !

Exemples de boucles imbriquées en C

Explorons quelques autres exemples pour solidifier notre compréhension :

1. Motif de nombres

#include <stdio.h>

int main() {
int i, j, rows = 5;
for (i = 1; i <= rows; i++) {
for (j = 1; j <= i; j++) {
printf("%d ", j);
}
printf("\n");
}
return 0;
}

Cela crée un motif de nombres :

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

2. Motif d'alphabets

#include <stdio.h>

int main() {
int i, j;
char current = 'A';
for (i = 1; i <= 5; i++) {
for (j = 1; j <= i; j++) {
printf("%c ", current++);
}
printf("\n");
}
return 0;
}

Cela imprime un motif d'alphabets :

A
B C
D E F
G H I J
K L M N O

3. Vérificateur de nombres premiers

#include <stdio.h>

int main() {
int i, j, flag;
printf("Nombres premiers entre 1 et 50 sont :\n");
for (i = 2; i <= 50; i++) {
flag = 0;
for (j = 2; j <= i/2; j++) {
if (i % j == 0) {
flag = 1;
break;
}
}
if (flag == 0)
printf("%d ", i);
}
return 0;
}

Ce programme trouve tous les nombres premiers entre 1 et 50. La boucle externe itère à travers les nombres, tandis que la boucle interne vérifie si chaque nombre est premier.

Conclusion

Les boucles imbriquées sont des outils puissants dans la boîte à outils du programmeur. Elles nous permettent de travailler avec des données multidimensionnelles et de créer des motifs complexes. Souviens-toi, la pratique rend parfait ! Essaie de modifier ces exemples ou crée tes propres programmes de boucles imbriquées.

Voici un tableau de référence rapide des types de boucles imbriquées que nous avons couverts :

Boucle externe	Boucle interne	Exemple d'utilisation
For	For	Créer des motifs 2D ou des tables
For	While	Opérations de longueur variable par ligne
While	For	Répéter une opération fixe un nombre variable de fois
While	While	Opérations basées sur double condition

Bonne programmation, et puisses tes boucles toujours être parfaitement imbriquées !

Credits: Image by storyset