Les instructions répétitives

I. Définition : Les instructions répétitives (les boucles) sont utilisées pour des traitements répétitifs.
C'est-à-dire qu'ils permettent d'exécuter un traitement plusieurs fois.
Comme tout traitement, une boucle doit s'exécuter un certain nombre de fois. Il faut donc,
après chaque exécution, prendre une décision de fin de boucle. Ceci se fait suivant une
condition de sortie de la boucle.
Par exemple :
Ecrire un algorithme qui permet d’afficher le mot ‘’bonjour’’ 50 fois. 50 : nombre de répétition.
Le traitement à répéter le mot ‘’Bonjour’’.
Remarque : on dit le nombre de répétition ou bien le nombre d’itérations (qui signifié le
passage d’un pas à l’autre dans une boucle).
On distingue trois types de boucles : La structure répéter jusqu'à, la structure tant que et la
structure pour.
II. Instruction de boucle « Répéter »

La structure répéter jusqu’à permet d’exécuter le bloc d’instruction jusqu’à la condition devient
vraie.

Syntaxe: Organigramme Action1;

Répéter Action2;
………
Action1;
Action2; Oui Non
……… Condition

Jusqu’à (Condition d’arrêt) ;

1. L'ordinateur exécute d'abord, sans aucune condition, la boucle (Action1, Action2, ….),
2. A la fin de la boucle, il évalue la condition,
2.1. Si elle est fausse :
2.1.1. L’ordinateur exécute la boucle,
2.1.2. Retourne à l’étape 1 pour réévaluer la condition,
2.2. Si elle est vraie :
2.2.1. L’ordinateur sort de la boucle puis, continu l’exécution du programme à
l’instruction qui vient tout de suite après « Jusqu’à ».

Dans l’exemple suivant, on remarque que la boucle « Répéter » est exécutée au moins une fois
sans avoir à initialiser la variable « x » à une valeur différente de zéro. De plus, on n’a pas besoin
de mettre les « actions » entre « Début » et « Fin ; »
Debut
Algorithme exemple1 ;
x, s : Réel ; S 0
Début
s 0; Organigramme
Lire(x)
Répéter
Lire (x) ; S s+x
s s+x;
Oui Non
Jusqu’à x = 0 ; X=0
Ecrire (s ) ; Ecrire(x)
Fin.
Fin
 Algorithme exemple2 ;
Var
x : Réel ;
Début
Lire (x) ;
Répéter
Ecrire ( ' x = ' , x ) ;
x x-1;
Jusqu'à x <= 0 ;
Fin.
Cette instruction est utilisée dans le cas ou le nombre de boucle à exécuter n'est pas connu. Elle
utilise une condition pour décider s’il faut, encore, exécuter un traitement (une boucle).

Syntaxe:
Tant Que (Condition vraie)
Non Oui
Faire Condition
Organigramme
Action1 ;
Action2 ; Action1;
Action2;
……….. ………
Fait ;

1. « Tant Que » évalue la condition :

1.1. Si elle est vraie :
1.1.1. Le programme exécute le ou les actons qui se trouvent dans la boucle,
1.1.2. A la fin du traitement (ou de la boucle), il retourne, automatiquement, à l’étape 1,
pour réévaluer la condition.
1.2. Si elle est fausse (non vraie), le programme sort de la boucle puis continu l’exécution à la
première action qui vient tout de suite après la boucle.

L’exemple suivant illustre le fonctionnement de la boucle « TantQue ».

Algorithme exemple ; Debut

Var
x : Entier ; Lire(x)
Début
Lire (x) ; Organigramme
Non Oui
X>0
Tant Que x > 0
Faire Ecrire(x)
Ecrire ( x ) ; Fin
x x-1; x x-1
Fait ;
Fin.

III. Instruction de boucle «Pour»

 On utilise la structure pour quand le nombre d’itération est connu à l’avance.
 Le compteur a une valeur initiale et une valeur finale.
 Le pas d’incrémentation du compteur égale à 1

Syntaxe
Pour Compt ← <Valeur_initiale> à <Valeur_finale>

Faire
Action 1 ;
Action 2 ;
……
Fait;

 Compteur est une variable numérique utilisée comme compteur de boucle. C’est-à-
dire, elle compte le nombre de fois d’exécution de l’action.
 Le bloc d’actions est exécuté un nombre connu de fois suivant le compteur.
 <valeur-initiale> indique la première valeur affectée à la variable compteur lors de l’exécution
de la première itération.
 <valeur-finale> indique la dernière valeur qu’aura la variable compteur lors de la dernière
itération.

Algorithme exemple ;
Var
N, i, X : Entier ;
Début
Lire (N) ;
Pour i 1 à N
Faire
X i*i;
Ecrire ( x) ;
Fait ;
Fin.