Instructions répétitives

les boucles
6 Instructions répétitives (les boucles)
6. 1 Introduction
Les structures itératives ou répétitives sont des
instructions qui permettent d’exécuter un traitement un
certain nombre de fois.
Ce sont des boucles qui répètent l’exécution d’un même
bloc d’instructions.
Pour réaliser et mettre en place une structure itérative on
doit connaître:
 Soit le nombre de répétition (itération),
 Soit la condition d’arrêt qui est une expression logique
qu’on vérifie avant ou après chaque répétition.
6 Instructions répétitives (les boucles)
6. 2 Instructions répétitives

En programmation on distingue deux grands types de

boucles. Deux cas selon:
1. le nombre d’itération ou répétition est connu avant
l’exécution de l’algorithme.
2. le nombre d’itération ou répétition n’est pas connu
avant l’exécution de l’algorithme.

Une itération signifie l’exécution de la liste des instructions

d’une boucle.
6 Instructions répétitives (les boucles)
Pour que la structure d’une boucle soit correct, il faut qu’elle
soit composée de quatre blocs élémentaires :
1. Bloc d’initialisation de la boucle: sert comme point de
départ des itérations;

2. Bloc de processus itératif ou corps de la boucle:

contient toutes les instructions à répéter à chaque
itération;

3. Bloc de progression (incrémentation) ou régression (

décrémentation) de l’indice ( compteur de la boucle):
c’est un compteur qui fait évoluer la boucle;

4. Bloc de test de continuation: effectue le contrôle pour

décider la continuation ou l’arrêt de la boucle.
Instructions répétitives (les boucles)
Pour comprendre l’intérêt des boucles, Prenons l’exemple
d’une saisie au clavier (une lecture): on pose une question à
laquelle l’utilisateur qui doit répondre par O (Oui) ou N (Non).
On pourrait essayer ça avec une structure si.
Algorithme saisie;
Var Rep : Caractère;
début
écrire("Voulez vous un café ? (O/N)"); //première demande
lire(Rep);
Si ((Rep <>"O") et (Rep <> "N")) alors
écrire("Saisie erronnée. Recommencez"); //deuxième demande
lire(Rep);
Finsi
Si ((Rep <>"O") et (Rep <> "N")) alors
écrire("Saisie erronnée. Recommencez"); //troisième demande
lire(Rep);
Finsi
Fin
Instructions répétitives (les boucles)
• Ça marche si l’utilisateur rentre une valeur correcte à la
première demande.
• Sinon, si l’utilisateur se trompe une seule fois, alors il doit
rentre une valeur correcte à la deuxième demande.
• Sinon, Sin l’on veut également éviter une deuxième erreur, il
faudrait rajouter un SI (deuxième demande).
• Et ainsi de suite, on peut rajouter des centaines de SI.
 Mais cela ne résout pas le problème. La seule issue est
l’utilisation d’une boucle.
Il existe trois types de boucle :
1. TantQue …FinTantQue
2. Répéter ... Jusqu'a
3. Pour … finPour
Chacune de ces boucles a ses avantages et ses inconvénients.
 Instructions répétitives (les boucles)
La boucle Tant que … fin tant que
La syntaxe d'une boucle Tant que est la suivante.
TantQue (condition) faire
instructions;
FinTantQue
 La condition est évaluée avant chaque passage dans la boucle,
 A chaque fois que la condition est vérifiée, on exécute les instructions de
la boucle,
 Une fois que la condition n'est plus vérifiée, l‘exécution se poursuit après
la boucle (FinTantQue)
 Si dès le début la condition est fausse, le traitement (les instructions de la
boucle) ne sera pas exécutée.
 La boucle TantQue peut s’exécuter 0, 1 ou n fois.(voir schéma 1)
Instructions répétitives (les boucles)
La boucle Tant que … fin tant que
Organigramme

Schéma 1 d’exécution d’une boucle « tantque »

 Instructions répétitives (les boucles)
La boucle : Tant que … fin tant que
Le principe de la boucle TantQue….FinTantQue est simple :
1. Le programme arrive sur la ligne du TantQue.
2. Il examine alors la valeur de la condition.
3. Si cette valeur est VRAI, le programme exécute les
instructions de la boucle, jusqu’à ce qu’il rencontre la ligne
FinTantQue.
4. Il retourne ensuite sur la ligne du TantQue, procède au
même examen, et ainsi de suite.
5. On ne s’arrête que lorsque la condition prend la valeur
FAUX.
Exemple : Afficher tous les nombres de 1 à 10 dans l'ordre croissant.
Algorithme nombreCroissant;
Var i: entier;
Initialisation
Debut
i  1; Test
TantQue (i<= 10) faire
Ecrire( i); Corps de la boucle
i  i + 1;
FinTantQue Incrémentation
Fin
• Cet algorithme initialise i à 1 et tant que la valeur de i n'excède pas 10,
cette valeur est affichée puis incrémentée.
• Les instructions se trouvant dans le corps de la boucle sont donc
exécutées 10 fois de suite.
• La variable i s'appelle un compteur, on gère la boucle par
incrémentations successives de i et on sort de la boucle une fois i est
supérieur à 10.
Attention: L'initialisation du compteur est très importante ! Si vous
n'initialisez pas i explicitement, alors cette variable contiendra n'importe
quelle valeur et votre algorithme ne se comportera pas du tout comme prévu.
Instructions répétitives (les boucles)
Exemple 2: Ecrire un algorithme permettant d’afficher
respectivement les nombres 10, 20, 30, 40 et 50.
Correction de l’exemple 2 :
Algorithme exemple2;
Var i: entier;
Début Initialisation

i 1; Test

TantQue (i<=5) faire

Ecrire(i*10); Corps de la boucle

i i + 1;
FinTantQue Incrémentation

Fin
 Instructions répétitives (les boucles)
ATTENTION: Une des instructions du corps de la boucle doit
absolument changer la valeur de la condition de vrai à faux
(après un certain nombre d'itérations), sinon le programme
tourne indéfiniment (boucle infinie).
Exemple d’une boucle infinie
Algorithme boucle_infinie;
Var A: réel; !!!!! Rien ne fait évoluer la
Début variable A qui reste
A  5; toujours égale à 5<20.
Tantque (A<20) Faire Il y aura donc un
affichage de la valeur 5
Ecrire(A); éternellement.
FinTQ
Fin
 Instructions répétitives (les boucles)
Exercice 2: Ecrire un algorithme qui lit un entier positif n puis
affiche tous ses diviseurs.
Correction de l’exemple 3:
Algorithme diviseurs;
Var n, i : Entier;
Début
Ecrire(”Entrer un entier positif : ”) ;
Lire(n); Initialisation
i  1; Test
TantQue (i <= n) Faire
Si (n Mod i = 0) Alors
Ecrire(i);
FinSi Corps de la boucle
i i + 1;
FinTQ Incrémentation
Fin
 Instructions répétitives (les boucles)
Exercice 4: Ecrire un algorithme qui lit un entier positif n puis
calcule et affiche son factoriel selon la formule n! = 1*2*… *n
Correction de l’exemple 4:
Algorithme facto;
Var n, f, i : Entier;
Début
Ecrire (”Entrer un entier positif : ”);
Lire (n);
Initialisation
f  1;
i  2; Test
TantQue (i <= n) Faire
f f * i;
i  i + 1; Corps de la boucle
FinTQ Incrémentation
Ecrire (n,”! = ”,f);
Fin.
 Instructions répétitives (les boucles)
La boucle : Répéter … jusqu’à
La syntaxe d'une boucle Répéter est la suivante:
Répéter
instructions;
Jusqu’à (Condition)

Comme la boucle tant que, on ne connaît pas le nombre de

répétition, mais on connaît la condition d’arrêt
Le même fonctionnement que TantQue, à quelques détails prés :
 la condition est évaluée après chaque passage dans la boucle.
 On exécute le corps de la boucle jusqu'a ce que la condition
soit vérifiée, donc tant que la condition est fausse.
La boucle Répéter ... jusqu‘à est donc exécutée au moins une fois. (
voir schéma 2)
 Instructions répétitives (les boucles)
La boucle : Répéter … jusqu’à (Organigramme)

Schéma 2 d’exécution d’une boucle « répéter »

 Instructions répétitives (les boucles)
La boucle : Répéter … jusqu’à
Le principe de la boucle répéter … jusqu’à est simple :
1. L’exécution du traitement dépend de la vérification de la
condition
2. La condition d’arrêt se trouve à la fin de la boucle. Ainsi, toutes
les instructions écrites entre Répéter et jusqu’à sont exécutées
au moins une fois,
3. leur exécution est répétée jusqu’à ce que la condition placée
derrière soit satisfaite.
 Instructions répétitives (les boucles)
La boucle Répéter … jusqu’à
Prenons l’exemple d’une saisie au clavier:
Algorithme saisie;
Var Rep: Caractère;
Début
Ecrire( "Voulez vous un café ? (O/N) ");
Répéter
Lire (Rep);
Si ((Rep <>"O") ET (Rep <>"N")) Alors
Ecrire ("Saisie erronée. Recommencez");
FinSi
Jusqu’a ((Rep ="O") OU (Rep ="N"));
Fin
 Instructions répétitives (les boucles)
Exemple 1: Afficher tous les nombres de 1 à 10 dans l'ordre croissant.
Algorithme nombreCroissant;
Var i: entier;
DEBUT
i  1;
Répéter
Ecrire( i);
i  i + 1;
Jusqu’à (i> 10);
FIN
 De la même façon que pour la boucle TantQue, le compteur est
initialisé avant le premier passage dans la boucle,

 Par contre, la condition de sortie de la boucle n'est pas la même,

 On ne sort de la boucle qu'une fois que la valeur 10 est affichée et la

valeur de i est supérieure à 10.
 Instructions répétitives (les boucles)
Exemple 1: Afficher tous les nombres de 1 à 10 dans l'ordre croissant.
Algorithme nombreCroissant;
Var i: entier;
Début
i  1;
Répéter
Ecrire( i);
i  i + 1;
Jusqu’à (i> 10);
Fin

 Or, i est incrémentée après l'affichage, par conséquent i aura la valeur

11 à la fin de l'itération pendant laquelle la valeur 10 aura été affichée.
 C'est pour cela qu'on ne sort de la boucle qu'une fois que i a dépasse
strictement la valeur 10.
Remarque: Un des usages les plus courant de la boucle Répéter ...
jusqu'a est le contrôle de saisie.
 Instructions répétitives (les boucles)
Exemple 2: Ecrire un algorithme permettant d’afficher
respectivement les nombres 10, 20, 30, 40 et 50.
Algorithme exemple2;
Var i: entier;
DEBUT Initialisation
i 1;
répéter Corps de la boucle
Ecrire(i*10);
i i + 1; Incrémentation

Jusqu’à(i>5); Test
Fin
Remarque: Dans une boucle « répéter…Jusqu’à », il faut toujours
s’assurer que la condition de sortie sera vérifiée après un nombre fini
de parcours. Sinon, c’est une boucle infinie.
 Instructions répétitives (les boucles)
Exercice 2: Ecrire un algorithme qui lit un entier positif n puis
affiche tous ses diviseurs.
Algorithme diviseurs;
Var n, i : Entier;
Début
Ecrire(”Entrer un entier positif : ”) ;
Lire(n);
i  1; Initialisation
Répéter
Si (n Mod i = 0) Alors Incrémentation
Ecrire(i);
FinSi Corps de la boucle
i i + 1;
Jusqu’à (i > n);
Fin Test
 Instructions répétitives (les boucles)
Exercice 2: Ecrire un algorithme qui lit un entier positif n puis
calcule et affiche son factoriel selon la formule n! = 1*2*… *n
Algorithme facto;
Var n, f, i : Entier;
Début
Ecrire(”Entrer un entier positif : ”);
Lire(n);
Initialisation
f  1;
i  2;
Répéter
f f * i; Corps de la boucle
i  i + 1;
Incrémentation
Jusqu’à (i > n) ;
Ecrire(n,”! = ”,f); Test
Fin.
 Instructions répétitives (les boucles)
La boucle Tant que … fin tant que
La syntaxe d'une boucle Tant que est la suivante.
TantQue (condition) faire
instructions;
FinTantQue
 La condition est évaluée avant chaque passage dans la boucle,
 A chaque fois que la condition est vérifiée, on exécute les instructions de
la boucle,
 Une fois que la condition n'est plus vérifiée, l‘exécution se poursuit après
la boucle (FinTantQue)
 Si dès le début la condition est fausse, le traitement (les instructions de la
boucle) ne sera pas exécutée.
 La boucle TantQue peut s’exécuter 0, 1 ou n fois.(voir schéma 1)
 Instructions répétitives (les boucles)
La boucle : Répéter … jusqu’à
La syntaxe d'une boucle Répéter est la suivante:
Répéter
instructions;
Jusqu’à (Condition)

Comme la boucle tant que, on ne connaît pas le nombre de

répétition, mais on connaît la condition d’arrêt
Le même fonctionnement que TantQue, à quelques détails prés :
 la condition est évaluée après chaque passage dans la boucle.
 On exécute le corps de la boucle jusqu'a ce que la condition
soit vérifiée, donc tant que la condition est fausse.
La boucle Répéter ... jusqu‘à est donc exécutée au moins une fois. (
voir schéma 2)
 Instructions répétitives (les boucles)
La boucle Pour … finPour
La syntaxe d'une boucle Pour est la suivante:
Pour variable  valeur initiale à valeur finale [pas] faire
Instructions
finPour
 La boucle Pour fait varier la valeur du compteur <variable> entre
< valeur initiale> et <valeur finale>.
 Le <pas> est optionnel et permet de préciser la variation du
compteur après chaque itération.
Par défaut, le pas est 1 et correspond à une incrémentation.
 Une boucle Pour peut être exécutée 0, 1 ou n fois.
 Toute boucle pour peut être réécrite avec une boucle tant que.
 Instructions répétitives (les boucles)
La boucle: Pour … finPour
Le compteur (ou variable de contrôle) prend la valeur initiale au
moment de l’accès à la boucle puis, après chaque itération, il passe
automatiquement à la valeur suivante dans son domaine jusqu’à
atteindre la valeur finale ( voir schéma 3):

Schéma 3 d’exécution
d’une boucle « pour »
 Instructions répétitives (les boucles)
La boucle Pour … finPour
Le principe de la boucle Pour est simple :
1. On initialise le compteur (i) au début par la valeur initiale
2. On test si le compteur (i) a dépassé la valeur finale
3. On exécute les instructions (corps de la boucle)
4. On incrémente le compteur (i  i + 1)
5. On test si le compteur n’a pas dépassé la valeur finale
6. etc.
 Instructions répétitives (les boucles)
La boucle Pour … finPour
Exemple :
On veut écrire un algorithme qui affiche le message "Bonjour à tous"
100 fois.
Résolution :
Au lieu d’écrire 100 fois l’instruction : écrire("Bonjour à tous") ;
On utilise plutôt une boucle Pour :
Algorithme message;
var i: Entier;
Début
Pour i allant de 1 à 100 faire
écrire("Bonjour à tous");
Finpour
fin
 Instructions répétitives (les boucles)
Exemple :
On peut améliorer l’algorithme précédent par :
• L’ajout d’un entier n : le nombre de fois que le message
s’affichera à l’écran,
• L’affichage de la variable i dans la boucle : pour numéroter les
passages dans la boucle.
Algorithme message2;
var
n, i: Entier;
Début
écrire("entrer le nombre n :");
lire(n);
Pour i allant de 1 à n faire
écrire("Bonjour à tous la ",i," fois");
Finpour
Fin
 Instructions répétitives (les boucles)
Exemple 1:
Afficher tous les nombres de 1 à 10 dans l'ordre croissant.

Algorithme nombreCroissant; Initialisation + test +

Var i: entier; Incrémentation
Début
Pour i1 à 10 faire
Ecrire( i);
FinPour Corps de la boucle
Fin

 Notez bien que l'on utilise une boucle pour quand on sait à
l’avance combien d'itérations devront être faites.
 Par exemple, n'utilisez pas une boucle pour afin de contrôler
une saisie ! « Voulez-vous un café? (O/N) ».
 Instructions répétitives (les boucles)
Remarque: Lorsque le nombre d’itération est connu avant l’exécution
de l’algorithme on utilise la boucle pour, sinon il faut utiliser soit:
1. la boucle Répéter …Jusqu’à
2. ou la boucle Tantque
Correction de l’exemple 2 ( avec la boucle Pour)
Ecrire un algorithme permettant d’afficher respectivement les
nombres 10, 20, 30, 40 et 50.
Algorithme exemple2; Initialisation + Test
Var + Incrémentation
i : Entier;
Début
Pour i 1 à 5 Faire
Ecrire(i*10);
Corps de la
FinPour
boucle
Fin
 Instructions répétitives (les boucles)
Remarque: Dans une boucle « Pour », l’évolution du compteur peut
se faire dans le sens décroissant comme dans l’exemple suivant :
Correction de l’exemple 2 (Décrémentation)
Algorithme exemple2bis; Initialisation +
Test+
Var i : Entier;
Décrémentation
Début
Pour i 5 à 1 [pas=-1] Faire
Ecrire(i*10); Corps de la
FinPour boucle

Fin
Dans ce cas, le compteur i sera décrémenté après chaque parcours.
 Instructions répétitives (les boucles)
Exemple 3 ( boucle Pour)
Ecrire un algorithme qui lit un entier positif n puis affiche tous
ses diviseurs.
Algorithme Diviseurs;
Var n, i : Entier;
Début Initialisation +
Ecrire(”Entrer un entier positif : ”); Test+
Incrémentation
Lire(n);
Pour i allant de 1 à n Faire
Si (n Mod i = 0) Alors Corps de la
Ecrire(i); boucle
FinSi
FinPour
Fin
 Instructions répétitives (les boucles)
Exemple 4 ( boucle Pour)
Ecrire un algorithme qui lit un entier positif n puis calcule et affiche
son factoriel selon la formule n! = 1*2*… *n
Algorithme Fact;
Var n, i, f : Entier;
Début
Ecrire(”Entrer un entier positif : ”);
Initialisation +
Lire(n); Test+
f 1; Incrémentation
Pour i  2 à n Faire
f  f * i; Corps de la
FinPour boucle
Ecrire(n,”! = ”,f);
Fin
 Instructions répétitives (les boucles)
La boucle Pour
Il faut éviter de modifier la valeur du compteur (et de finale) à
l'intérieur de la boucle. En effet, une telle action :
 perturbe le nombre d'itérations prévu par la boucle Pour
 rend difficile la lecture de l'algorithme
 présente le risque d'aboutir à une boucle infinie
Exemple
Pour i allant de 1 à 5
i  i -1;
écrire(" i = ", i);
Finpour
 Instructions répétitives (les boucles)
Lien entre Pour et TantQue
 La boucle Pour est un cas particulier de TantQue (cas où le
nombre d'itérations est connu et fixé) .
 Tout ce qu'on peut écrire avec Pour peut être remplacé avec
TantQue (la réciproque est fausse)
Pour compteur allant de initiale à finale [pas] faire
instructions
FinPour
Peut être remplacé par :
compteur ← valeur initiale (cas d'un pas positif)
TantQue compteur <= finale faire
instructions
compteur ← compteur+pas
FinTantQue
 Instructions répétitives (les boucles)
Passage d’une structure itérative à une autre

(*) : Le passage d’une boucle « Répéter » ou « Tantque » à une boucle «

Pour » n’est possible que si le nombre de parcours est connu à l’avance.
(**) : Lors du passage d’une boucle « Pour » ou « Tantque » à une boucle
« Répéter », faire attention aux cas particuliers (traitement sera toujours
exécuté au moins une fois).
 Instructions répétitives (les boucles)
Critères de choix de la structure itérative adéquate
Instructions répétitives (les boucles)
Les Boucles imbriquées
Les instructions d'une boucle peuvent être des instructions
itératives. Dans ce cas, on aboutit à des boucles imbriquées
Exemple
Afficher un triangle rempli d'étoiles, s'étendant sur un nombre de
lignes fourni en donnée et se présentant comme dans cet exemple :
*
**
***
****
*****
******
Instructions répétitives (les boucles)
Les Boucles imbriquées
Algorithme triangle;
Var
n, i : entier
Debut
Ecrire (" Entrez la valeur de n ")
Lire (n)
pour i allant de 1 a n par un pas de 1 faire
Pour j allant de 1 a i par un pas de 1 faire
Ecrire("*")
FinPour
EcrireLn()
FinPour
Fin
130
Algorithme Test; Exercice1 (exemple de question):
Var
Donner le résultat d'exécution du
i, c, x, y, z : entiers;
Début programme suivant?
x← 20;
Pour i allant de 0 à 6 par pas de 3 faire
x ← x+2*i; Le résultat d'exécution du programme
Ecrire(‘x=’, x); est :
FinPour Boucle 1 (Pour)
i← 2; Iteration 1 x=20
y← 0; Iteration 2 x=26
Tanque(i<7) faire Iteration 3 x=38
y← y-i; Boucle 2 (Tantque)
Ecrire (‘ y=’, y); Iteration 1 y=-2
i← i+2; Iteration 2 y=-6
FinTantQue Iteration 3 y=-12
z← 3; Boucle 3 (Répéter)
c← 0; Iteration 1 c=30
Répéter Iteration 2 c=50
c← c+10*z; Iteration 3 c=60
Ecrire (‘ c=’, c);
z← z-1;
Jusqu'à (z=0);
Fin
Exercice2 (exemple de question):
Donner le résultat de l’algorithme suivant, si on saisit N=4 à
l’exécution.
Algorithme boucle1; Entrée Sortie Test
Var N, i: Entier; N=5, S=0,
S: Réel; i=0
Début i=1 S=0+1/1 1>=5 FAUX
Ecrire(" saisir un entier N:");
i=2 S=1+1/2 2>=5 FAUX
Lire(N);
S←0; i=3 S=1+1/2+1/3 3>=5 FAUX
i←0; i=4 S=1+1/2+1/3+1/4 4>=5 FAUX
Répéter i=5 S=1+1/2+1/3+1/4+1/5 5>=5 VRAI
i←i+ 1;
 On sort de la
S←S+ 1/i;
boucle
Jusqu’à (i>=N)
Ecrire(‘’ S=’’,S); Affichage du résultat
Fin S=1+1/2+1/3+1/4=2.28
La simulation de l’exécution
Exercice 3: Solution avec la boucle Tantque
Ecrire un algorithme qui permet d’afficher les nombres
impaires inférieure à 20 et de calculer leur somme.
Algorithme nombreImpair;
Var i,S: entiers;
Début
i1;
S0;
Ecrire(" les nombres impair inférieur à 20 sont: ");
Tantque (i<=20) Faire
Si(i MOD 2<>0) alors
Ecrire(i);
SS+i;
Finsi
i← i+1;
FinTantQue
Ecrire(‘’ La somme des nombres impairs <20 est ’’, S);
Fin
Exercice 3: Passage de la boucle Tantque à la boucle Répéter
Ecrire un algorithme qui permet d’afficher les nombres
impaires inférieure à 20 et de calculer leur somme.
Algorithme sommeNbreImpair2;
Var
S, i: entiers;
Début
S←0;
i←1;
Répéter
si(i MOD 2<>0) alors
Ecrire(i);
S←S+ i;
Finsi
i← i+1;
Jusqu’à (i>20);
Ecrire(‘’ la somme des Nbrs impairs=’’,S);
Fin
 Instructions répétitives (Exercices)
Exercice 4
Ecrire un algorithme permettant de :
1. lire un nombre fini de notes, comprises entre 0 et 20 (pas de
control se saisie)
2. afficher la meilleure note, la mauvaise note et la moyenne de
toutes les notes.
Algorithme Notes; Solution avec la boucle Pour
Var
n, i : Entier;
note, min, max, s : Réel;
Début
Ecrire(”Entrer le nombre de notes : ”);
Lire(n); //On suppose que n est toujours supérieur à zéro
s 0;
max  0;
min  20; Initialisation + test+
Incrémentation
Pour i de 1 à n Faire
Ecrire(”Entrer une note : ”) ;
Lire(note);
s  s + note;
Si (note > max) Alors
max note; Corps de la
boucle
FinSi
Si (note < min) Alors
min  note;
FinSi
FinPour
Ecrire(”La meilleure note = ”, max, ”La mauvaise note = ”, min );
Ecrire(”La moyenne des notes = ”, s/n);
Fin.
Algorithme Notes; Passage de la boucle Répéter à la boucle Tantque
Var
n, i : Entier;
note, min, max, s : Réel;
Début
Ecrire(”Entrer le nombre de notes : ”);
Lire(n); (* On suppose que n est toujours supérieur à zéro *)
s 0;
max  0; min  20; Initialisation
i1;
Tantque( i<=n) faire Test de la boucle
Ecrire(”Entrer une note : ”) ;
Lire(note);
s  s + note;
Si (note > max) Alors
max note;
FinSi Corps de la
Si (note < min) Alors boucle
min  note;
FinSi
incrémentation
ii+1;
FinTantque
Ecrire(”Meilleure note = ”,max, ”Mauvaise note = ”,min,”Moyenne des notes = ”,s/n );
Fin.
Exercice 5: Ecrire un algorithme permettant de :
1. Calculer le nombre de personnes et la moyenne d’âges
des personnes s’intéressant à voir un film particulier dans un
cinéma.
2. Avant de finir, l’utilisateur doit répondre par ‘N’ à la question
posé par l’algorithme: ‘’ encore une autre personne (O/N)?’’
Analyse du problème:

age Algorithme NP, M_age

Moyenne d’âges
V. entrées: âges des personnes: age
V. sorties: la moyenne d’âges: M_age
V. intermédiaires: la somme d’âges: S_age
compteur du nombre de personnes: NP
réponse à la question: rep
Le formules: S_age S_age+age
NP NP+1 jusqu’à rep=‘N’
M_age S_age/NP
 Algorithme avec la Boucle REPETER…
Algorithme moyenne_age;
Var age, S_age, NP: entier;
M_age : réel:
Rep : caractère;
Début
S_age 0;
NP 0;
Répéter
Lire(age);
NP NP+1;
S_age S_age+age;
Ecrire(‘’encore une autre personne (O/N)?’’);
Lire(rep);
Jusqu’à ( rep=‘N’);

M_age S_age/NP;
Ecrire(‘’ la moyenne d’ages est =’’,M_age);
Ecrire(‘’ le nombre de personnes saisi est =’’,NP);
Fin