Université Polytechnique Hauts-de-France

Institut National des Sciences Appliquées Hauts-de-France 2022-2023

Licence Sciences, Technologies, Santé Informatique - Semestre 1
Fiche 3

La répétition. Il est souvent nécessaire de répéter plusieurs fois une ou plusieurs actions au sein d’un
algorithme. On peut, par exemple, devoir afficher la valeur des entiers de 10 à 1 à l’écran pour simuler
un compte à rebours. Il serait trop fastidieux de procéder en écrivant Écrire(“10”) ; Écrire(“9”) ; . . . (les
. . . n’étant pas reconnnus comme une instruction par la machine !) Heureusement, plusieurs schémas de
répétition sont définis pour cela.

Définition 1 Le schéma (ou la boucle) tant que permet de répéter une ou plusieurs actions, tant qu’une
condition est vérifiée.

Le tant que se traduit en pseudo-langage sous la forme suivante :

tant que(condition) faire
action1 ;
action2 ;
fin tant que

Fonctionnement du tant que. Comme pour l’alternative, la condition est d’abord évaluée. Si elle est
vérifiée, alors on exécute la ou les actions à l’intérieur de la boucle. Une fois celles-ci terminées, on évalue
à nouveau la condition. Si elle est vérifiée on recommence les actions, et ainsi de suite jusqu’à ce que la
condition ne soit plus vérifiée.

Remarque 1 sur les répétitions. On utilise souvent le terme boucle pour faire référence aux schémas répé-
titifs. Le fait d’exécuter la ou les instructions au sein d’une boucle est ce qu’on appelle faire une itération.

Remarque 2 sur le tant que

— pour que la ou les actions soient effectuées au moins une fois, il faut que la condition soit évaluée
comme étant vraie au départ, sinon on ne rentre pas dans la boucle.
— on sort de la boucle lorsque la condition est évaluée FAUX, ce qui implique qu’au moins une action
réalisée à l’intérieur de la boucle doit influer sur la condition.

Exercice 1 :
Simuler le déroulement des trois algorithme suivants et indiquer les valeurs affichées.

Programme exo1b
VAR a, b, c : Entier ;
Programme exo1a
début
VAR i : Entier ;
Écrire("Entrer un entier : ") ; Lire(a) ;
début
b ← a; c ← 0 ;
i ← 1;
tant que(b ≥ 5) faire
tant que(i ≤ 7) faire
b ← b − 7;
Écrire(i) ; i ← i + 1 ;
c ← c + 1;
fin tant que
fin tant que
fin
Écrire(b, c) ;
fin

Programme exo1c
n ← n + 1;
VAR c : Caractère ;
si(c ≥ ’a’ ET c ≤ ’z’) alors
b : Booléen ;
b ← VRAI ;
n : Entier ;
fin si
début
fin tant que
b ← FAUX ; n ← 0 ;
Écrire(c, n) ;
tant que(b = FAUX) faire
fin
Lire(c) ;

1
Exercice 2 :
Dérouler l’algorithme suivant en considérant que les 5 séquences de valeurs suivantes (une valeur est associée
à chaque instruction Lire(c)) :
1. 5
2. 3 9 10
3. 3 6 84
4. 1 4 2 6 10 2 6 12 3 6 8 1 11 0
5. 1 9 2 -1 2 8 1 0 2 2 12 7

Programme exo2
VAR n, c : Entier ;
début
Lire(c) ; n ← 0 ;
tant que(c > 0 ET c < 4) faire
tant que(c > 0 ET c < 4) faire
Lire(c) ;
fin tant que
tant que(c < 8 ET c > 1) faire
n ← n + 1;
Lire(c) ;
fin tant que
Lire(c) ;
fin tant que
Écrire(n) ;
fin

Définition 2 Le schéma répéter . . . jusqu’à consiste à répéter une ou plusieurs actions, jusqu’à ce qu’une
condition soit vérifiée.

répéter
action1 ;
action2 ;
jusqu’à(condition) ;

Fonctionnement du jusqu’à. Dans ce schéma, on commence par exécuter les actions, puis on évalue la
condition. Si elle est vérifiée, alors on sort de la boucle, sinon on réitère.

Remarque 3 sur le jusqu’à

— ici la ou les actions sont toujours effectuées au moins une fois.
— on sort de la boucle lorsque la condition est évaluée VRAI.

Définition 3 Le schéma faire ... tant que est une autre variante qui consiste aussi à répéter une ou
plusieurs actions, mais cette fois tant qu’une condition est vérifiée.

faire
action1 ;
action2 ;
tant que(condition) ;

Fonctionnement du faire ... tant que. Dans ce schéma, comme pour le jusqu’à, on commence par
exécuter les actions, puis on évalue la condition. Si elle est vérifiée, alors on reste dans la boucle, sinon on
sort de la boucle.

Remarque 4 sur le faire ... tant que

— la boucle jusqu’à n’existe pas dans tous les langages de programmation. La variante faire . . . tant que
est alors souvent disponible.

2
 — cette boucle est un "mixte" entre le tant que et le jusqu’à : on effectue toujours au moins une fois les
actions, et on sort de la boucle lorsque la condition est évaluée FAUX.

Exercice 3 :
1. Écrire un algorithme qui affiche tous les nombres entiers impairs supérieurs à 0 et inférieurs à 100 avec
une boucle tant que.
2. Transformer cet algorithme pour utiliser une boucle jusqu’à, puis une boucle faire ... tant que.
Exercice 4 :
Écrire trois versions (une pour chaque boucle) d’un algorithme demandant à l’utilisateur de saisir un nombre
entier positif. La saisie sera répétée jusqu’à ce que le nombre entré soit bien positif.
Exercice 5 :
Écrire un algorithme qui demande un nombre de départ, puis qui écrit la table de multiplication de ce
nombre (jusque 10), en utilisant une boucle jusqu’à, puis en utilisant une boucle faire ... tant que.

Définition 4 Le schéma pour consiste à répéter une ou plusieurs actions en comptant le nombre d’ité-
rations qui sont exécutées. Ce schéma nécessite l’utilisation d’une variable, dite compteur, qui va être
incrémentée ou décrémentée automatiquement à chaque passage dans la boucle. Plusieurs éléments sont
nécessaires à la définition de cette boucle :
— il faut définir un intervalle caractérisé par la première et la dernière valeur prises par le compteur.
— il faut préciser le pas avec lequel le compteur est modifié à chaque itération.
Deux variantes existent, selon que le compteur a sa valeur qui augmente ou diminue :
pour cpt de départ à arrivée pas le_pas faire pour cpt de arrivée bas départ pas le_pas faire
action1 ; action1 ;
action2 ; action2 ;
fin pour fin pour

Fonctionnement du pour. Dans le premier cas, la variable cpt est initialisée à la valeur départ. Si cette
valeur est inférieure (respectivement supérieure dans le cas 2) à la valeur arrivée alors l’algorithme exécute la
ou les actions. Ensuite, la valeur du cpt est incrémentée (resp. décrémentée) automatiquement de la valeur
le_pas, et le processus recommence, jusqu’à ce que cpt atteigne une valeur supérieure (resp. inférieure) ou
égale à la valeur de arrivée.
Remarque 5 sur le pour : on note une différence au niveau des mots clés utilisés. Lorsque la valeur du
compteur augmente on utilise le mot clé à entre les deux valeurs. Dans le cas où la valeur du compteur
diminue on remplace ce mot clé par bas pour indiquer que la valeur diminue.
Équivalence. On remarque une certaine équivalence entre les 3 schémas de répétition (tant que, jusqu’à et
pour). Il est en fait possible de faire certaines transformations :
— il est toujours possible de transformer une boucle tant que en boucle jusqu’à
— il est toujours possible de transformer une boucle jusqu’à en boucle tant que
— il est toujours possible de transformer une boucle pour en boucle tant que, et donc en boucle jusqu’à
— il n’est pas toujours possible de transformer une boucle tant que (ni une boucle jusqu’à) en boucle
pour

Exercice 6 :
Que font les deux algorithmes suivants ?

Programme exo6b
Programme exo6a
VAR i, n, t : Entier ;
VAR i, n : Entier ;
début
début
Écrire("Entrer un entier : ") ; Lire(n) ; t ← 0 ;
Écrire("Entrer un entier : ") ; Lire(n) ;
pour i de 2 à n pas 2 faire
pour i de n + 1 à n + 10 pas 1 faire
t ← t + i;
Écrire(i) ;
fin pour
fin pour
Écrire(t) ;
fin
fin

3
Exercice 7 :
Écrire un algorithme avec une boucle pour qui fait la somme des entiers de 1 à 10 et affiche le résultat.

Exercice 8 :
1. Écrire un algorithme qui demande successivement 10 nombres à l’utilisateur, et qui lui indique ensuite
quel est le plus grand saisi.
2. Réécrire l’algorithme précédent en changeant la boucle utilisée et en affichant en plus le rang auquel
ce plus grand nombre a été saisi.
Exercice 9 :
Simuler le déroulement des deux algorithmes suivants, dans lesquels l’instruction aller_à_la_ligne est une
instruction prédéfinie du pseudo-langage permettant de passer à la ligne dans l’affichage.

Programme exo9b
Programme exo9a
VAR i, j : Entier ;
VAR i, j : Entier ;
début
début
pour i de 1 à 9 pas 1 faire
i ← 1 ;
Écrire(i, " : ") ;
tant que(i ̸= 4) faire
j ← 1;
pour j de 1 à 5 pas 1 faire
tant que (j ≤ 10) faire
Écrire(i, " ") ;
Écrire(i * j, " ") ;
fin pour
j ← j + 1 ;
aller_à_la_ligne ;
fin tant que
i ← i + 1;
aller_à_la_ligne ;
fin tant que
fin pour
fin
fin

Transformer les deux algorithmes précédents pour n’utiliser que des boucles "pour".

Exercice 10 :
On veut dessiner à l’écran un ’L’ et un ’I’ sur plusieurs lignes à l’aide du caractère ’*’ comme dans les
exemples ci-dessous :

1. Écrire un algorithme qui demande à l’utilisateur la lettre à reproduire à l’écran, puis la largeur (qui
doit être impaire) et la hauteur de la lettre, puis réalise le "dessin".
2. Écrire un algorithme qui dessine à l’écran un carré plein, rempli du caractère ’*’, d’une largeur saisie
par l’utilisateur.
3. Écrire un algorithme qui affiche à l’écran un triangle forme d”*’, dont la hauteur est saisie au clavier,
et qui respecte le format suivant (pour une hauteur de 6 par exemple) :