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

Un algorithme ne se contente pas toujours d’exécuter une suite d’instructions une seule fois. Il doit parfois répéter une action plusieurs fois : afficher une série de nombres, additionner plusieurs valeurs, ou demander une saisie jusqu’à obtenir une réponse correcte. Les boucles permettent cette répétition automatique.

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.

Objectifs pédagogiques

* Comprendre la notion de boucle et de répétition d’instructions. * Savoir utiliser les boucles Pour et TantQue. * Identifier quand utiliser chaque type de boucle. * Éviter les erreurs classiques de boucle infinie.

Plan du chapitre

1. Pourquoi répéter des instructions ?
2. La boucle POUR : répéter un nombre connu de fois
3. La boucle TANT QUE : répéter jusqu’à ce qu’une condition soit remplie
4. Les erreurs fréquentes dans les boucles
5. Applications directes

1. Pourquoi répéter des instructions ?

Définition

Une boucle est une structure qui permet de répéter un ensemble d’instructions plusieurs fois, soit un nombre déterminé de fois, soit jusqu’à ce qu’une condition soit remplie.

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.

Exemple

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.

Astuce

Pour bien comprendre le rôle d’une boucle, imaginez un professeur qui fait l’appel des élèves : il répète la même action (lire un nom) pour chaque élève présent. Une boucle fait exactement cela dans un programme : elle **répète une action pour chaque valeur** ou **jusqu’à une certaine condition**.

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

Définition

La boucle Pour est utilisée lorsque le nombre de répétitions est connu à l’avance. Elle utilise une variable appelée compteur qui augmente (ou diminue) automatiquement à chaque itération.

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.

Exemple

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.

Astuce

Le compteur peut aussi être utilisé dans les calculs. Par exemple : ```text Pour i de 1 à 4 Écrire "Carré de ", i, " = ", i * i FinPour ``` Ici, chaque itération calcule et affiche le carré du nombre en cours. Cela montre que le compteur n’est pas qu’un simple outil de contrôle, mais aussi une **valeur utile** dans les calculs. Il peut servir à créer des suites, à additionner des valeurs ou à remplir des tableaux.

Erreur fréquente

Oublier d’écrire la borne correcte ou inverser les valeurs de début et de fin peut empêcher la boucle de s’exécuter. Par exemple : ```text Pour i de 10 à 1 Écrire i FinPour ``` ne fera rien si le langage n’interprète pas la descente automatique. Pour parcourir dans l’autre sens, il faut préciser un pas négatif, par exemple : ```text Pour i de 10 à 1 pas -1 Écrire i FinPour ``` Le mot-clé pas indique ici de combien la variable i change à chaque tour.

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

Définition

La boucle TantQue est utilisée lorsque le nombre de répétitions n’est pas connu à l’avance. Elle continue tant qu’une condition donnée reste vraie.

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.

Exemple

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.

Astuce

Il existe une variante appelée Répéter…Jusqu’à, qui vérifie la condition à la fin au lieu du début : ```text Répéter Lire n Jusqu’à n >= 0 ``` Cette structure garantit qu’au moins une exécution aura lieu avant le test. Elle est utile lorsque l’on souhaite que les instructions s’exécutent **au moins une fois**, quoi qu’il arrive.

Erreur fréquente

Une erreur fréquente consiste à oublier de modifier la variable utilisée dans la condition. Cela provoque une **boucle infinie**, qui ne s’arrête jamais. Par exemple : ```text Début x ← 0 TantQue x \leq 5 Écrire x FinTantQue Fin ``` Ici, x ne change jamais, donc la condition x \leq 5 reste toujours vraie. Pour éviter cela, il faut s’assurer que la variable évolue à chaque itération : ```text Début x ← 0 TantQue x \leq 5 Écrire x x ← x + 1 FinTantQue Fin ``` La boucle s’arrête alors naturellement lorsque x atteint 5.

4. Les erreurs fréquentes dans les boucles

Erreur fréquente

Une erreur courante consiste à écrire une boucle dont la condition reste toujours vraie : c’est une boucle infinie. Par exemple : ```text TantQue x \leq 10 Écrire x FinTantQue ```

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 :

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

Exemple correct

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.

Astuce

Pensez à décomposer votre boucle : - **Initialiser** la variable avant la boucle. - **Modifier** la variable à chaque itération. - **Vérifier** la condition d’arrêt pour être sûr qu’elle deviendra fausse à un moment donné.

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

À retenir

Une boucle permet de répéter un ensemble d’instructions plusieurs fois.
La boucle Pour s’utilise quand le nombre de répétitions est connu.
La boucle TantQue s’utilise quand la répétition dépend d’une condition.
Il faut toujours prévoir une condition de sortie pour éviter les boucles infinies.

Prochain chapitre

Dans le prochain chapitre, vous apprendrez à manipuler les tableaux pour stocker plusieurs valeurs dans une seule variable.