Chapitre 4 — Les boucles et la répétition d’instructions

Sans boucle, il faudrait réécrire les mêmes instructions encore et encore, ce qui rendrait le programme long, répétitif et difficile à modifier.
Grâce aux boucles, l’algorithme peut accomplir une tâche répétée de façon compacte, rapide et fiable.

On peut comparer une boucle à une roue : elle tourne tant que la condition n’a pas changé.
Chaque tour de la roue correspond à une itération : un passage complet dans la séquence d’instructions.
L’algorithme décide ensuite, selon la situation, de continuer à tourner ou de s’arrêter.

Ce principe est fondamental : il permet à un programme de parcourir une liste, de compter, de vérifier des données, ou de traiter plusieurs éléments similaires sans tout réécrire à la main.

1. Pourquoi répéter des instructions ?

Imaginons que l’on veuille afficher les nombres de 1 à 10.
Sans boucle, il faudrait écrire dix instructions Écrire à la suite.
Avec une boucle, une seule structure suffit : l’algorithme répète l’action automatiquement.

Début
    Pour i de 1 à 10
        Écrire i
    FinPour
Fin

Cet algorithme affiche les nombres de 1 à 10 sans les écrire un par un. La variable i joue ici le rôle de compteur : elle prend successivement toutes les valeurs de 1 à 10, puis la boucle s’arrête.

On peut comparer une boucle à une machine automatique qui exécute la même tâche plusieurs fois à la suite. Plutôt que de répéter le geste manuellement, on programme la machine pour qu’elle le fasse à notre place. En algorithmique, c’est exactement le même principe : la boucle permet de répéter une action sans la réécrire.

Les boucles sont donc indispensables dès qu’une tâche doit être répétée de manière systématique. Elles permettent de simplifier le code, de réduire les erreurs et d’augmenter la clarté de l’algorithme.

2. La boucle POUR : répéter un nombre connu de fois

Sa structure générale est la suivante :

Pour variable de valeur_début à valeur_fin
    instructions répétées
FinPour

Le mot-clé Pour indique le début de la boucle, et FinPour marque sa fin. La variable de contrôle (souvent appelée i, j ou k) change de valeur à chaque passage, ce qui fait avancer la boucle pas à pas.

Début
    Pour i de 1 à 5
        Écrire "Bonjour"
    FinPour
Fin

Cet algorithme affiche cinq fois le mot « Bonjour ». La variable i prend successivement les valeurs 1, 2, 3, 4 et 5. Une fois que la valeur maximale (5) est atteinte, la boucle s’arrête automatiquement. Ici, i ne sert qu’à compter les répétitions, mais on peut aussi l’utiliser dans les calculs.

On peut comparer la boucle Pour à une échelle : à chaque itération, on monte une marche, jusqu’à atteindre la dernière. L’algorithme sait dès le départ combien de marches il devra gravir.

La boucle Pour est donc idéale lorsque le nombre d’itérations est connu à l’avance : afficher dix lignes, parcourir une liste d’élèves, répéter un calcul un nombre fixe de fois, etc.

3. La boucle TANT QUE : répéter jusqu’à une condition

Sa structure est la suivante :

TantQue condition
    instructions répétées
FinTantQue

Le principe est simple : avant chaque passage dans la boucle, l’algorithme vérifie la condition. Si elle est vraie, le bloc d’instructions est exécuté. Dès qu’elle devient fausse, la boucle s’arrête et le programme continue normalement.

Début
    Lire n
    TantQue n \leq 0
        Écrire "Erreur, entrez un nombre positif."
        Lire n
    FinTantQue
    Écrire "Merci, nombre accepté."
Fin

Ici, l’algorithme redemande une valeur tant qu’elle est négative. La condition n \leq 0 est donc le critère de poursuite : tant qu’elle reste vraie, la boucle continue. Dès que l’utilisateur entre un nombre positif, la condition devient fausse, et la boucle s’arrête.

On peut comparer ce mécanisme à une porte qui reste ouverte tant qu’une règle n’est pas respectée. Chaque fois que la condition est vraie, on repasse par la porte et on répète les instructions. Lorsqu’elle devient fausse, la porte se referme et l’algorithme passe à la suite.

Cette boucle est utile dans tous les cas où on ne sait pas à l’avance combien de fois l’action devra être répétée. Par exemple :

• redemander une saisie jusqu’à ce qu’elle soit correcte ;
• répéter un tirage aléatoire jusqu’à obtenir un certain résultat ;
• traiter une liste jusqu’à ce qu’elle soit vide.

4. Les erreurs fréquentes dans les boucles

Ici, la variable x n’est jamais modifiée, donc la condition x \leq 10 restera toujours vraie et l’algorithme ne s’arrêtera jamais. L’ordinateur continue d’exécuter les mêmes instructions à l’infini, sans jamais atteindre la fin.

On appelle cela une boucle sans condition de sortie. Elle est très fréquente lorsque l’on oublie d’incrémenter ou de modifier la variable de contrôle. C’est comme si vous montiez un escalier sans jamais avancer : vous répétez le même geste, mais vous restez au même endroit.

Pour éviter ce problème, il faut anticiper la sortie de la boucle avant même de l’écrire. Autrement dit, demandez-vous toujours :

« Qu’est-ce qui fera que ma boucle s’arrête ? »

Cela garantit que la condition finira par devenir fausse à un moment donné.

Un bon algorithme comporte toujours trois étapes bien définies :

1. Initialisation – on prépare les variables avant d’entrer dans la boucle.
2. Modification – on change au moins une variable à chaque itération.
3. Condition d’arrêt – on définit clairement le moment où la répétition doit cesser.

Début
    x ← 0
    TantQue x \leq 10
        Écrire x
        x ← x + 1
    FinTantQue
    Écrire "Boucle terminée."
Fin

Ici, la variable x est bien modifiée à chaque tour de boucle.
Lorsque x atteint la valeur 10, la condition x \leq 10 devient fausse, et l’algorithme s’arrête correctement.

Cette méthode évite la plupart des erreurs de logique et rend vos boucles plus fiables. En résumé, une boucle bien conçue est une boucle dont on connaît à l’avance le point d’entrée et le point de sortie.

On peut retenir que la clé d’une boucle correcte est l’équilibre entre la répétition et la progression. Chaque tour doit rapprocher un peu plus l’algorithme de sa condition d’arrêt.

5. Applications directes

Exercice 1 : Écrire un algorithme qui affiche les nombres de 1 à 10.

Début
    Pour i de 1 à 10
        Écrire i
    FinPour
Fin

Entrée : — Sortie : 1 2 3 4 5 6 7 8 9 10

Cet exercice montre comment utiliser une boucle Pour pour générer une suite de nombres sans répétition manuelle.

Exercice 2 : Écrire un algorithme qui calcule la somme des entiers de 1 à 5.

Début
    somme ← 0
    Pour i de 1 à 5
        somme ← somme + i
    FinPour
    Écrire "Somme = ", somme
Fin

Entrée : — Sortie : Somme = 15

L’algorithme additionne les valeurs successives de 1 à 5 grâce à la boucle Pour. À chaque passage, la variable somme s’enrichit d’une nouvelle valeur.

Exercice 3 : Écrire un algorithme qui redemande une note tant qu’elle n’est pas comprise entre 0 et 20.

Début
    Lire note
    TantQue note \leq 0 ou note > 20
        Écrire "Erreur, la note doit être comprise entre 0 et 20."
        Lire note
    FinTantQue
    Écrire "Note valide : ", note
Fin

Entrée : -5, 25, puis 14 Sortie : Note valide : 14