Chap4 ST
Transféré par
PROF PROFChap4 ST
Transféré par
PROF PROFLes boucles .
36
Chapitre 4 : Les boucles
1. Introduction
Lorsqu on veut répéter une opération ou un bloc d opérations
plusieurs fois dans un algorithme, il est possible d utiliser des
structures répétitives (itératives) appelées les boucles. Il existe
trois types de boucles : 'Tant que', 'Répéter' et 'Pour'.
2. La boucle Tant que
Format général : Tant que <Condition> Faire <Séquence>.
Cette structure permet la répétition d une séquence d opérations
tant que la condition est satisfaite (= VRAI). Quand la condition
devient fausse la boucle est terminée.
La condition est une expression logique. Il faut alors que cette
expression puisse changer de valeur (avoir la valeur FAUX) pour
sortir de la boucle et éviter le cas de la "boucle infinie".
La séquence est une ou plusieurs opérations. Pour plusieurs
opérations, le début et fin sont obligatoires. Dans le cas d'une
seule opération le début et fin sont optionnels.
La boucle Tant que est représentée dans un organigramme
comme suit :
NON OUI
<condition>
Séquence
Voyons l exemple suivant qui permet d afficher les valeurs de 1 à
10 :
!"!# ;
Tant que (i <= 10) Faire début
Ecrire (i) ;
!"! !$!# ;
fin ;
En Pascal, la boucle Tant que s exprime comme suit :
i := 1 ;
Les boucles . 37
while (i <= 10) do begin
writeln (i);
i := i + 1 ;
end ;
3. La boucle Répéter
Format général : Répéter <Séquence> Jusqu%à <Condition>.
Cette structure permet la répétition d une ou plusieurs opérations
jusqu à ce qu une condition soit vérifiée (= VRAI). Pour éviter la
boucle infinie, il faut que la condition puisse changer de valeur
(avoir la valeur VRAI).
La séquence peut contenir une ou plusieurs opérations. Dans les
deux cas, début et fin sont facultatifs.
La boucle Répéter peut être représentée dans un organigramme
comme suit :
Séquence
NON
OUI
<condition>
Reprenons l exemple permettant d afficher les valeurs de 1 à 10 :
!"!#&
Répéter
Ecrire (i);
!"! !$!#&
Jusqu%à (i > 10) ;
En Pascal, la boucle Répéter s exprime comme suit :
i := 1 ;
repeat
write (i);
i := i + 1 ;
until (i > 10)
Remarque : Pour la boucle Tant que et Répéter, on utilise
souvent une variable, dite indice, initialisée à une valeur initiale
avant d'exécuter la boucle. A l'intérieur de la boucle, l'indice sera
incrémenté (en ajoutant une valeur à la valeur courante), ou
Les boucles . 38
décrémenté (en diminuant la valeur courante) pour atteindre la
condition d'arrêt de la boucle.
Le tableau suivant récapitule les différences entre les deux
boucles Tant que et Répéter:
Condition
Condition Nombre Début et fin pour la
Boucle pour
d exécution d exécutions séquence
quitter
n est pas connu Obligatoires si la
d avance, mais séquence contient
Condition = Condition elle peut ne jamais plusieurs opérations,
Tant que
VRAI = FAUX être exécutée si la et facultatifs si la
condition = FAUX séquence contient une
dès le départ. seule opération.
n est pas connu Facultatifs dans les
Condition = Condition d avance, mais deux cas.
Répéter
FAUX = VRAI elle est exécutée
au moins une fois.
4. La boucle Pour
Format général :
Pour <Compteur> "! '()*+,-! . / )*+0! 1! '()*+,-! 2 .)*+0!
pas de <Incrément> Faire <Séquence>. Cette structure permet
de répéter une séquence d opérations pour toutes les valeurs d une
variable dite variable de contrôle (Compteur) à partir d une
valeur initiale à une valeur finale.
Le nombre de répétition de la séquence d instructions est connu
d avance. Après chaque exécution du corps de la boucle, la
variable de contrôle est augmentée d'une unité (Incrément). La
valeur par défaut de l incrément est égale à 1 (dans le cas où on ne
la précise pas).
La variable de contrôle est de type entier. La valeur initiale et la
valeur finale sont des constantes ou des variables de type entier.
Ces deux valeurs permettent de calculer le nombre de répétition
de la séquence :
nbr = valeur finale - valeur initial + 1 (dans le cas où le pas est
égal à 1).
Remarques :
Dans une boucle Pour, le compteur (variable de contrôle)
peut être utilisé, mais il ne doit jamais être modifié à
l intérieur de la boucle.
Les boucles . 39
Par convention, lorsque l'incrément est égal à 1, il n'est pas
indiqué.
La première valeur, la dernière valeur et l'incrément peuvent
être des expressions numériques.
La boucle Pour peut être représentée dans un organigramme
comme suit :
OUI NON
<condition>
Séquence
Gardons le même exemple permettant d afficher les valeurs de 1 à
10 :
34,-! !"!#!1!#5!6) -+!78- -+!9 : ;
En Pascal, la boucle pour s exprime comme suit : for i := 1 to 10
do write(i) ;
L'instruction : for i := 10 downto 1 do write(i) ; affiche les
valeurs de 10 à 1.
Remarques :
En Pascal, la notion de pas de progression n existe pas
explicitement. Le pas est défini implicitement par les
expressions to (pour un pas de + 1) et down to (pour un pas
de -1).
L instruction for est redondante car elle peut être exprimée
par les boucles while ou repeat, mais il est recommandé
d utiliser la boucle for chaque fois que c'est possible.
Pascal permet d utiliser les formes suivantes :
for car := ;a% to ;z% <4!= ;
for car := ;z% downto ;a% <4!= ;
for bl >?!2)*@+!/4!/-,+!<4!= ;
for bl >?!/-,+!<4A./4!2)*@+!<4!= ;
avec (car : char et bl : boolean).
Le compteur ne doit pas être modifié à l intérieur de la boucle
for, mais la modification de la valeur initiale et la valeur
finale n a aucun effet sur le nombre de répétition de la
séquence d instructions.
Pour la boucle for i >?!B!/4!C!<4!= ; avec x>y
Les boucles . 40
ou la boucle for i >?!B!<4A./4!C!<4!= ; avec x<y,
la séquence n est jamais exécutée.
Pour la boucle for i >?!B!/4!B!<4!= ;
ou la boucle for i >?!B!<4A./4!B!<4!= ;
la séquence est exécutée une seule fois.
Après avoir quitté la boucle for i >?!B!/4!.!<4!= ; l indice i
prend la valeur n.
5. Les boucles imbriquées
Les boucles peuvent être imbriquées les unes dans les autres. Une
boucle Tant que peut contenir une autre boucle Tant que, une
autre boucle Répéter, ou une autre boucle Pour, et vice versa. De
plus, une boucle peut contenir une autre boucle, qui elle-même
peut contenir une autre boucle et ainsi de suite.
L algorithme suivant permet d afficher les tables de multiplication
de 1 jusqu à 10.
Algorithme boucles_imbriquées ;
Variables
i, j : entier ;
Début
!"!# ;
Tant que (i<=10) Faire début
D!"!# ;
Répéter
Ecrire (i, ;*%, j, ;=%, i*j) ;
D!"!D!$!# ;
Jusqu%à (j > 10) ;
!"! !$!# ;
Fin ;
Fin.
L organigramme correspondant à l algorithme précèdent est le
suivant :
Les boucles . 41
Début
!"!#
NON OUI
i <= 10
Fin D!"!#
78- -+!9 E!;F%E!DE!;?%E! FD:
D!"!!D!$!#
NON
j > 10
OUI
!"!! !$!1
6. Exercices corrigés
6.1. Exercices
Exercice 1 :
Ecrire des algorithmes permettant de calculer la somme de la suite
!"#$%&'()"#$*+$,+$-+$.+$%$/%$"st un entier lu à partir du clavier) en
utilisant les boucles : Tant que, Répéter et Pour. Traduire ces
algorithmes en langage Pascal.
Exercice 2 :
Ecrire un algorithme qui calcule la factorielle d un nombre entier
n strictement positif sachant que :
%0$1$*2,2-2.2%+$"3$45"
0! = 1, par convention (n! se lit : n factorielle).
La factorielle d un nombre négatif n existe pas. Il est donc
nécessaire que l algorithme vérifie si le nombre donné n est pas
négatif.
Traduire l algorithme en Pascal.
