Chapitre 3 : Les structures répétitives

I. Introduction

Prenons le cas d’une saisie au clavier, par exemple, on pose une question à la laquelle l’utilisateur
doit répondre par O (Oui) ou N (Non).

L’utilisateur risque de taper autre chose (une autre lettre), le programme peut soit planter par une
erreur d’exécution soit se dérouler normalement jusqu’au bout, mais en produisant des résultats
fantaisistes.

Pour remédier à ce problème, on peut mettre en place un contrôle de saisie pour vérifier que les
données entrées au clavier correspondent bien à celles attendues par l’algorithme.

On pourrait essayer avec un SI

Algorithme contrôle_de_saisie
Variables Rep : caractère
Début
Ecrire(‘’Voulez vous une copie de ce cours ? (O/N)’’)
Lire(Rep)
Si Rep <> ‘O’ et Rep <> ‘N’ alors
Ecrire(‘’Erreur de saisie.Recommencez’’)
Lire(Rep)
FinSi
Fin

L’algorithme ci-dessus résout le problème si on se trompe qu’une seule fois, et on fait entrer une
valeur correcte à la deuxième demande. Sinon en cas de deuxième erreur, il faudrait rajouter un SI.
Et ainsi de suite, on peut rajouter des centaines de SI.

La solution à ce problème consiste à utiliser une structure répétitive.

Une structure répétitive, encore appelée boucle, est utilisée quand une instruction ou une liste
d’instructions, doit être répétée plusieurs fois. La répétition est soumise à une condition.

II. La boucle TantQue……….Faire.

La boucle TantQue permet de répéter un traitement tant que la condition est vraie.

Syntaxe :
TantQue condition Faire
Instruction (s)

FinTantQue

L’exécution de la boucle dépend de la valeur de la condition. Si elle est vraie, le programme exécute
les instructions qui suivent, jusqu'à ce qu’il rencontre la ligne FinTantQue. Il retourne ensuite sur la
ligne TantQue, procède au même examen, et ainsi de suite.
La boucle ne s’arrête que lorsque la condition prend la valeur fausse, et dans ce cas le programme
poursuit son exécution après FinTantQue.

Exemple

Algorithme contrôle_de_saisie
Variables Rep : caractère
Début
Ecrire(‘’Voulez-vous une copie de ce cours ? (O/N)’’)
Lire(Rep)
TantQue Rep <> ‘O’ et Rep <> ‘N’ Faire
Ecrire(‘’Erreur de saisie.Recommencez’’)
Lire(Rep)
FinTantQue
Fin

Remarque

Etant donné que la condition est évaluée avant la mise en œuvre des instructions, ce qui est
une sécurité, il est possible que celles-ci ne soient jamais exécutées.
Si une structure TantQue dans la laquelle la condition ne devient jamais une fausse. Le
programme tourne dans une boucle infinie et n’es sort plus.

Exemple : boucle infinie

Dans l’exemple ci-dessous nous avons une boucle infinie, l’ordinateur ne s’arrêtera jamais d’afficher
le message Bonjour car la variable I qui est testée dans la condition n’est jamais incrémentée :

I1
TantQue I<=10 Faire
Ecrire(‘Bonjour)
FinTantQue

Exercice :

Ecrire un algorithme qui calcule S=1+2+3+4+5 ……………….+N

III. La boucle Pour…………Faire

La boucle Pour….Faire permet de répéter une liste d’instructions un nombre connu de fois.

Syntaxe :
Pour compteurvaleur_initiale jusqu’à valeur_finale Faire
Instruction (s)

FinPour
La variable compteur est de type entier. Elle est initialisée à la valeur initiale. Le compteur augmente
sa valeur de un (1) automatiquement à chaque tour de boucle jusqu’à la valeur finale.

Pour chaque valeur prise par la variable compteur, la liste des instructions est exécutée.

Lorsque la variable compteur vaut la valeur finale, le traitement est exécuté une dernière fois puis le
programme sort de la boucle.

Exemple :

Les instructions suivantes :

Pour k0 jusqu’à 10 faire
Mul 7*k
Ecrire (‘’7*’’,k,’’=’’,mul)
FinPour

Le programme affiche à l’écran la table de multiplication de 7.

7*0=0 7*6=42
7*1=7 7*7=49
7*2=14 7*8=56
7*3=21 7*9=63
7*4=28 7*10=70
7*5=35

Exercice :

Ecrire un algorithme permettant de calculer la somme des 10 premiers nombres entiers.

Remarque

Par défaut la variable compteur est incrémenté de 1 à chaque tour de la boucle

Pour modifier la valeur d’incrémentation, il suffit de rajouter le mot Pas (en anglais Step) et
la valeur de ce pas à la boucle Pour.

Syntaxe générale de la structure Pour est :

Pour compteurvaleur_initiale jusqu’à valeur_finale Pas ValeurPas Faire
Instruction (s)

FinPour

Exercice :

Ecrire un algorithme qui permet de saisir un nombre entier et qui calcule la somme des entiers pairs
jusqu'à ce nombre. Par exemple, si l’on saisit 10, le programme doit calculer :
0+2+4+6+8+10=30
 IV La boucle Répéter…………Jusqu’à

Cette boucle sert à répéter une instruction jusqu’à ce qu’une condition soit vraie.

Remarque

Cette boucle ne s’utilise en général que pour des menus, elle est dangereuse car il n’ y’a pas de
vérification de la condition avant d’y entrer !

Syntaxe :
Répéter
Instruction (s)

Jusqu’à condition

La liste d’instruction est exécutée, puis la condition est évaluée. Si elle est fausse, le corps de la
boucle est exécuté à nouveau puis la condition est réévaluée et si elle a la valeur vrai, le programme
sort de la boucle et exécute l’instruction qui suit Jusqu’à.

Exercice

En utilisant la boucle Répéter…..Jusqu’à, écrire un algorithme qui calcule la somme des N premiers
nombres entiers. On suppose que N est strictement positif.

Remarque

Les boucles « Répéter » et « TantQue » sont utilisées lorsqu’on ne sait pas au départ le
combien de fois il faudra exécuter ces boucles.
A la différence de la boucle « TantQue », la boucle « Répéter » est exécutée au moins une
fois.
La condition d’arrêt de la boucle « Répéter » est la négation de la condition de poursuite de
la boucle « TantQue ».
On utilise la boucle « Pour » quand l’on connait le nombre d’itération à l’avance.