Boucles et répétitions
Ce que ce chapitre apporte
- 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. Restons à 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.
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
programme principal
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 s'en charge. 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, imaginer 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.
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
programme principal
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 :
programme principal
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 :
programme principal
aucune variable
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 :
programme principal
Le mot-clé pas indique ici de combien la variable i change à chaque tour.
La question que se pose tout débutant, « par où l'algorithme repasse-t-il pour recommencer ? », a une réponse visuelle. Le parcours Flowgorithm dessine la boucle avec la flèche qui remonte, celle qui ramène au test. C'est le seul trait d'un organigramme qui aille vers le haut, et il porte à lui seul toute l'idée de répétition.
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
programme principal
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 :
programme principal
aucune variable
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 :
programme principal
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 :
programme principal
La boucle s'arrête alors naturellement lorsque x atteint 5.
Les trois autres erreurs de boucle
La boucle sans fin, vue ci-dessus, est la plus spectaculaire. Les trois suivantes sont plus sournoises : le programme se termine, et le résultat est faux.
programme principal
somme ← 0 est dans la boucle : il s'exécute à chaque tour
programme principal
La colonne somme retombe à zéro à chaque ligne : le tableau montre la remise à zéro là où le texte doit la décrire. Le résultat affiché n'est pas la somme, c'est la contribution du dernier tour.
et efface le total précédent. L'algorithme affiche 3 au lieu de 6. L'initialisation appartient à ce qui précède la boucle, jamais à son corps.
Pour i de 1 à 10 fait dix tours, pas neuf : les deux bornes sont comprises. Pour i de 0 à 10 en fait onze.
Le contrôle qui ne trompe jamais : compter les tours pour une petite valeur. Pour i de 1 à 3 doit afficher trois lignes. Si le résultat en donne deux ou quatre, l'erreur est dans les bornes et nulle part ailleurs.
programme principal
Le Pour gère lui-même l'avancement de i. Y toucher rend l'algorithme illisible, et le nombre de tours dépend alors du langage dans lequel on le traduira. Quand il faut un pas irrégulier, c'est un TantQue qu'il faut écrire, où l'avancement est explicite.
programme principal
Pour un Pour, la réponse est donnée par les bornes. Pour un TantQue, elle doit être écrite à la main, dans le corps de la boucle, et c'est la ligne qu'on oublie.
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
programme principal
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.
Penser à décomposer la 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 les 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.
Vérification
1.Pour i de 1 à 10 fait combien de tours ?
2.Où placer somme ← 0 dans un algorithme qui additionne les nombres d'une liste ?
3.Qu'est-ce qui fait qu'un TantQue finit par s'arrêter ?
4.Quand préférer Répéter … Jusqu'à à un TantQue ?
5.Modifier i à l'intérieur d'un Pour i de 1 à 10 fait quoi ?
Exercices type
Exercice 1 : Écrire un algorithme qui affiche les nombres de 1 à 10.
Afficher la solution
programme principal
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
programme principal
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
programme principal
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 : Notons 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.
La méthode
- Choisir la boucle d'après ce qu'on sait. Nombre de tours connu d'avance : une boucle
Pour. Nombre dépendant d'une condition : une boucleTantQue. - Répondre à la question d'arrêt avant d'écrire quoi que ce soit : qu'est-ce qui fera qu'elle s'arrête ? Pour un
TantQue, la réponse doit figurer dans le corps. - Vérifier les trois temps d'un
TantQue: initialiser avant, modifier à chaque tour, vérifier au bon endroit. Oublier le deuxième donne une boucle infinie. - Compter les tours aux bornes.
Pour i de 1 à 10en fait dix,Pour i de 0 à 10en fait onze. Les deux bornes sont comprises. - Placer l'accumulateur avant la boucle, et vérifier qu'aucune remise à zéro ne s'est glissée à l'intérieur.
- Ne jamais toucher au compteur d'une boucle
Pourdans son corps : elle gère elle-même son avancement.
Synthèse
- 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.
Mettre en pratique
Compter les tours, placer l'accumulateur, et savoir ce qui fait qu'une boucle s'arrête.
- Combien de tours2 · Fonctions
- L'accumulateur au mauvais endroit3 · Confirmé
- Ce qui fait qu'elle s'arrête3 · Confirmé