Boucles et répétitions
Objectifs du Chapitre
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.
Écrire cent fois la même instruction n'est pas seulement pénible : c'est impossible à maintenir, et impossible dès que le nombre de répétitions n'est connu qu'à l'exécution. Les boucles règlent les deux. Reste à choisir la bonne : Pour quand on sait combien de fois, TantQue quand on sait seulement jusqu'à quand.
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 ?
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
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.
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
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 :
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
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.
Le compteur peut aussi être utilisé dans les calculs. Par exemple :
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.
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 :
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 :
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
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 :
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
Ici, l’algorithme redemande une valeur tant qu’elle est négative. La condition n <= 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.
Il existe une variante appelée Répéter…Jusqu’à, qui vérifie la condition à la fin au lieu du début :
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.
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 :
Ici, x ne change jamais, donc la condition x <= 5 reste toujours vraie. Pour éviter cela, il faut s’assurer que la variable évolue à chaque itération :
La boucle s’arrête alors naturellement lorsque x atteint 5.
4. Les erreurs fréquentes dans les boucles
Une erreur courante consiste à écrire une boucle dont la condition reste toujours vraie : c’est une boucle infinie. Par exemple :
Ici, la variable x n’est jamais modifiée, donc la condition x <= 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
Ici, la variable x est bien modifiée à chaque tour de boucle.
Lorsque x atteint la valeur 10, la condition x <= 10 devient fausse, et l’algorithme s’arrête correctement.
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. À toi de jouer
Exercice 1 : Écrire un algorithme qui affiche les nombres de 1 à 10.
Afficher la solution
Sortie attendue : 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.
Afficher la solution
Sortie attendue : 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.
Afficher la solution
Déroulons avec les saisies −5, puis 25, puis 14 :
| Tour | note lue | note < 0 ou note > 20 | Ce qui se passe |
|---|---|---|---|
| avant la boucle | −5 | vrai | on entre dans la boucle |
| 1 | 25 | vrai | message d'erreur, on redemande |
| 2 | 14 | faux | on sort de la boucle |
| après | 14 | (sortie) | affiche : Note valide : 14 |
Écrire note <= 0 au lieu de note < 0. Une note de 0 sur 20 est valide : elle serait rejetée à l'infini, et l'étudiant qui a vraiment eu 0 ne pourrait jamais la saisir. Les bornes sont toujours l'endroit où les conditions se trompent.
La première lecture est avant le TantQue, sinon la condition testerait une variable sans valeur. Et la seconde lecture est dans la boucle, sinon la condition ne changerait jamais : c'est ce qui fait qu'on en sort.
- Une boucle répète un ensemble d'instructions.
Pourquand le nombre de répétitions est connu d'avance,TantQuequand il dépend d'une condition.- Le compteur d'un
Pouravance tout seul : ne l'incrémente pas une seconde fois. - Dans un
TantQue, quelque chose dans le corps doit finir par rendre la condition fausse, sinon la boucle ne s'arrête jamais.
Et ensuite ? Le chapitre Tableaux montre comment stocker plusieurs valeurs sous un seul nom, ce qui rend enfin utile tout ce que tu viens d'apprendre sur les boucles.