Vous êtes sur la page 1sur 5

LES STRUCTURES REPETITIVES

LES STRUCTURES REPETITIVES


I. Définition :
Une structure répétitive est une structure qui répète un même traitement autant de fois que l’on veut
en fonction d’une condition d’exécution.
Cette structure s’arrête lorsque cette condition n’est plus vérifiée.
On distingue deux types de répétitions :
➢ L’Itération : quand on sait le nombre de fois que l’on va répéter un traitement :
▪ La boucle Pour.
➢ La Répétition Conditionnelle : quand la poursuite d’une répétition dépend d’une condition
booléenne :
▪ La boucle Tant que.
▪ La boucle Répéter.
L’utilisation d’un tel ou tel schéma dépend essentiellement de la nature du problème à résoudre.

II. La boucle Pour :


1. Définition :

La boucle Pour est une structure répétitive qui itère le même traitement pour une plage de valeurs
entières comprises entre une borne inférieure et une borne supérieure. La mise à jour étant
automatique, l’arrêt du traitement de la boucle Pour se réalise lorsqu’on dépasse l’une des bornes.

2. Représentation algorithmique :

Pour I de Val_initiale à Val_finale, (Pas = Val_pas) Faire


<Traitement>
Fin Pour

3. Représentation en langage C :

for ( I= Val_initiale ; I<= Val_finale ; I++)


{
<Traitement> ;
}

Avec
I : variable de type entier (en général) servant de compteur.
Val_initiale : valeur initiale que va prendre I.
Val_finale : valeur finale que prendra I.
Pas : contient une valeur entière indiquent la valeur de l’incrémentation de I (mise à jour de I).
Du fait que le nombre d'itérations est connu à l’avance, on se sert d'un compteur (ici I) qui sera
initialisé automatiquement à la valeur initiale et sera incrémenté de la valeur du pas, jusqu'à la
valeur finale.
1
LES STRUCTURES REPETITIVES

Remarque :

• Le traitement de la boucle Pour est exécuté pour toutes les valeurs comprises entre
Val_initiale et Val_finale.
• Le sens de la boucle Pour peut-être croissant (Pas > 0) ou décroissant (Pas < 0).
• Si la valeur du Pas = 0, on sera en présence d’une boucle infinie.
• L’incrémentation de I est automatique en fonction de la valeur du Pas.
• Dans le corps de la boucle il est interdit de modifier la valeur du compteur I, même si on peut
s'en servir.
• Dans une boucle Pour, si le Pas n’apparaît pas, il vaut 1 par défaut.
• La boucle Pour est conseillée si le nombre d’itérations à faire est connu à l’avance.

4. Exécution de la Boucle Pour :

On suppose qu’on est déjà entrain d’exécuter un algorithme, et on a rencontré une boucle Pour.
1ère étape : Affectation de Val_initiale au compteur I.
2ème étape : Vérification si la valeur de I est dans l’intervalle ou non, si elle est dans l’intervalle
alors aller à la 3ème étape, sinon aller à la 5ème étape.
3ème étape : Exécution du traitement de la boucle.
4ème étape : Incrémentation automatique de la valeur de I en fonction de la valeur du Pas (I I +
Val_pas) et retour à la 2ème étape.
5ème étape : Sortie de la boucle et suite de l’exécution du programme à partir de la première
instruction qui vient après Fin pour.
5. Exercices d’application :

Exercice N°1 :
Ecrire un programme C qui lit un entier positif et affiche son factoriel :
n!=1*2*3*……*n-1* n et 0!=1
Exercice N°2 :

Ecrire un programme C qui lit un réel x et un entier positif n et affiche x puissance n.


Exercice N°3 :
Ecrire un programme C qui permet de saisir les moyennes des N étudiants et de calculer la moyenne
générale.

Exercice N°4 :
Ecrire un programme C qui permet d'afficher tous les nombres pairs qui existent entre 1 et n.
Exercice N°5 :
Ecrire un programme C qui permet de saisir un nombre entier n et d'afficher s'il est premier ou non.
Un nombre premier est divisible uniquement par 1 et par lui-même.

Exercice N°6 :
Ecrire un programme C qui détermine si un entier N est parfait ou non. Un entier est dit parfait s'il
est égal à la somme de ses diviseurs stricts (Exemple: 6=3+2+1).
Exercice N°7 :
Ecrire un programme C qui permet de calculer parmi les entiers de 1 à n :
• La somme des entiers pairs
• La somme des entiers impairs

2
LES STRUCTURES REPETITIVES

III. La boucle Répéter :


1. Définition :

La boucle Répéter permet de rentrer dans la boucle quelque soit la condition et réitère l’exécution
jusqu'à ce que la condition soit vérifiée.
La condition est une expression logique qui peut être simple ou composée mais qui donne toujours
un résultat logique.

2. Représentation Algorithmique :

Répéter
<Traitement>
<mise_à_jour_condition_arrêt>
Jusqu'à (Condition_Arrêt_Atteinte)

3. Représentation en langage C (Répéter…TantQue) :

do
{<Traitement> ;
<mise_à_jour_condition_exécution>;
}while ( Condition_exécution_vérifiée) ;

Remarque :

• Dans une boucle Répéter, le traitement est exécuté au moins une seule fois quelle que soit la
valeur de la condition d’arrêt.
• Dans une boucle Répéter, on parle de condition d’arrêt ; quand elle est atteinte, on sort de cette
boucle.
• Il est indispensable d’initialiser correctement les variables de la condition d’arrêt et de les
mettre à jour à la fin de chaque itération : condition nécessaire et obligatoire pour pouvoir
reboucler.
• La structure Répéter est conseillée surtout pour les problèmes indiquant dans leur énoncé une
condition d’arrêt.

4. Exécution de la Boucle Répéter :

On suppose qu’on est déjà entrain d’exécuter un algorithme, et on a rencontré une boucle Répéter.
1ère étape: on entre directement dans le traitement associé à Répéter et on l’exécute.
2ème étape: on met à jour les variables impliquées dans la condition d’arrêt.
3ème étape: on teste la condition d’arrêt : si elle n’est pas atteinte, on revient à la 1ère étape, sinon on
passe à la 4ème étape.
4èmeétape: la condition d’arrête étant atteinte, on sort de la boucle Répéter et on continue
l’exécution du programme à partir de la 1ère instruction qui vient après Jusqu’à.

Remarque :

Si la condition d’arrêt reste inchangée (non mise à jour), on risque de reboucler indéfiniment et par
conséquent le programme se bloque.

3
LES STRUCTURES REPETITIVES

5. Exercices d’application :

Exercice N°8 :

Ecrire un programme C qui lit un nombre entier et s’arrête dès qu’il devienne supérieur à 100.
Exercice N°9 :
Ecrire un programme C qui calcule la moyenne de N note (avec note entre 0 et 20).
Exercice N°10 :
Ecrire un programme C qui lit un entier et affiche son carré et ne s'arrête que si on entre la valeur 0.
Exercice N°11 :
Ecrire un programme C qui prend en paramètre un entier positif N et qui affiche la somme de ses
chiffres.
Exemple : N=152 → S=8
N=1584 → S=18

IV. La boucle Tant que :


1. Définition :

La boucle Tant que permet d’exécuter le corps de la boucle lorsque la condition d’exécution est
vérifiée ; on s'arrêtera dès que la condition n’est plus vérifiée.

2. Représentation Algorithmique :

……….
Initialisation des variables de la condition d’exécution
Tant que (Condition_exécution_vérifiée) Faire
<Traitement>
<mise_à_jour_condition_exécution>
Fin Tant que
………
3. Représentation en langage C

while (Condition_exécution_vérifiée)
{ <Traitement> ;
<mise_à_jour_condition_exécution> ;
}
Remarque :

• Dans une boucle Tant que, le traitement associé à la boucle peut ne pas être exécuté : la
condition d’exécution n’est pas vérifiée dès le départ.
• Dans une boucle Tant que, on parle de condition d’exécution ; quant elle n’est plus vérifiée,
on sort de cette boucle.
• Il est indispensable d’initialiser correctement les variables de la condition d’exécution et de
les mettre à jour à la fin de chaque itération : condition nécessaire et obligatoire pour pouvoir
reboucler.
• La mise à jour de ces variables peut se faire soit par une lecture, soit par une affectation.
• La structure Tant que est conseillée surtout pour les problèmes indiquant dans leur énoncé une
condition d’exécution.
• Une condition d’exécution est la négation de la condition d’arrêt.
4
LES STRUCTURES REPETITIVES

4. Exécution de la Boucle Tant que :

On suppose qu’on est déjà entrain d’exécuter un algorithme, et on a rencontré une boucle Tant que.
On suppose également que les variables impliquées dans la condition d’exécution sont initialisées.
1ère étape : On teste si la condition d’exécution est vérifiée ou non : si oui alors aller à la 2ème étape
sinon aller à la 5ème étape.
2ème étape : On exécute le traitement associé à la boucle.
3ème étape : On met à jour les variables de la condition d’exécution.
4ème étape : Aller à la 1ère étape.
5ème étape : On sort de la boucle et on continue l’exécution du programme à partir de la première
instruction qui vient après Fin Tant que.

Remarque : Si la condition d’exécution reste inchangée (non mise à jour), on risque de reboucler
indéfiniment et par conséquent le programme se bloque (boucle infinie).

5. Exercices d’application :

Exercice N°12 :

Ecrire un programme C calculant la somme des N premiers entiers.

Exercice N°13 :

Ecrire un programme C qui permet de saisir un nombre pair et qui détermine combien de fois ce
nombre est divisible par 2.
Exemple : 8 est divisible 3 fois par 2 (2*2*2).

Exercice N°14 :

Ecrire un programme C qui permet de faire des opérations sur un entier (valeur initiale à 0).

L’algorithme affiche la valeur de l’entier puis affiche le menu suivant :


1. Ajouter 1
2. Multiplier par 2
3. Soustraire 4
4. Quitter
L’algorithme demande alors de tapez un entier entre 1 et 4. Si l’utilisateur tape une valeur entre 1 et
3, on effectue l’opération, on affiche la nouvelle valeur de l’entier puis on réaffiche le menu et ainsi
de suite jusqu’à ce qu’on tape 4.
Lorsqu’on tape 4, l’algorithme se termine.

V. Remarques générales :
➢ Le <Traitement> d'une boucle peut contenir lui aussi une autre boucle. On l'appelle dans ce cas
des boucles imbriquées.
➢ La différence entre la boucle REPETER et la boucle TANTQUE est que le traitement spécifié
est exécuté au moins une fois dans le premier cas et peut être 0 ou plusieurs fois dans le
deuxième cas.
➢ La condition d'arrêt de la boucle REPETER est l'inverse de la condition d'exécution de la
boucle TANTQUE.

Vous aimerez peut-être aussi