CHAPITRE 2

LES STRUCTURES DE CONTROLE

1. Introduction

En règle générale, les instructions d’un algorithme s’exécutent les unes à la

suite des autres, dans l’ordre où elles sont écrites. Ce processus s’appelle exécution
séquentielle. On a par conséquent besoin de disposer de mécanismes de contrôle
supplémentaires permettant de décrire avec précision les différentes articulations
d’un algorithme. Ces mécanismes de contrôle sont appelés les structures de
contrôle.
Les structures de contrôle sont des constructions algorithmiques qui permettent
de regrouper et d’organiser les instructions afin de décrire avec précision la façon
dont les instructions doivent être exécutées dans un algorithme.
On distingue trois structures de contrôle de base au moyen desquelles on peut
contrôler l’exécution des instructions dans un algorithme :
- la structure séquentielle
- la structure de sélection
- la structure de répétition
Ce sont les blocs de construction de base à partir desquels on peut écrire
n’importe quel algorithme.

2. La structure séquentielle

Dans une structure séquentielle, les instructions sont exécutées les unes à la
suite des autres, dans l’ordre où elle sont écrites. Une structure séquentielle se
présente donc sous la forme :

instruction1 ;
instruction2 ;
...
instruction n ;

Une structure séquentielle est généralement délimitée par les mots réservés début
et fin, définissant une instruction composée dont la forme générale est :

1
 début
instruction1 ;
instruction2 ;
...
instruction n ;
fin ;

3. La structure de sélection

On a souvent besoin de rendre l’exécution d’une instruction ou d’un groupe

d’instructions dépendante d’une certaine condition. Ceci implique la capacité de
changer l’ordre dans lequel les instructions sont exécutées ou la capacité de choisir,
en fonction de ce que l’on veut faire, les instructions qui doivent être exécutées.
Considérons l’exemple suivant : on voudrait écrire un algorithme pour lire deux
nombres réels, diviser le premier par le second et imprimer le quotient.

L‘algorithme apparaît assez simple et une version initiale serait :

début
Lire le dividende et le diviseur
Diviser le dividende par le diviseur
Écrire le résultat
fin.

Lorsque cette version originale est raffinée, on obtient la version suivante :

Exemple 1. Algorithme de division de deux nombres réels

algorithme Division1 ;
var
A, B, Q : réel ;
début
lire(A) ;
lire(B) ;
Q  A/B ;
Écrire(Q) ;
fin.

L’algorithme ci-dessus marchera correctement aussi longtemps que l’on prendra la

précaution de ne pas donner au diviseur la valeur zéro. Comme la division par zéro
n’est pas permise, l’exécution de l’algorithme avec des données de ce genre va
résulter en une erreur de condition. On peut améliorer l’algorithme ci-dessus en
testant d’abord la valeur du diviseur pour voir si elle est égale à zéro et effectuer

2
ensuite la division uniquement si elle n’est pas nulle. L’algorithme va maintenant
ressembler à quelque chose du genre :

début
Lire le dividende et le diviseur
si diviseur = 0 alors
Écrire un message indiquant une mauvaise entrée
sinon
Diviser le dividende par le diviseur et écrire le résultat
fin.

La structure si…alors…sinon

Pour écrire l’algorithme ci-dessus, nous avons eu besoin d’un moyen de

représenter une condition devant être testée ; le résultat du test devant déterminer
ce que l’on doit faire par la suite. Nous l’avons fait en utilisant l’instruction
si…alors…sinon. Dans le langage algorithmique, cette instruction prend la forme
générale suivante :

si (condition) alors
opérations
sinon
opérations;

La condition entre les mots réservés si et alors est une expression qui peut prendre
soit la valeur vrai soit la valeur faux. Si elle prend la valeur « vrai » alors les
opérations qui suivent la clause alors sont effectuées. Si elle prend la valeur faux
alors les opérations qui suivent la clause sinon sont effectuées.

Dans notre exemple, la condition correspond à l’expression :

Diviseur = 0

L’opération à effectuer si la condition prend la valeur vrai est :

Écrire un message indiquant une erreur de donnée

L’opération à effectuer si la condition prend la valeur faux est :

Diviser le dividende par le diviseur et écrire le résultat

Pour écrire correctement cet algorithme, nous avons utilisé l’instruction si…
alors…sinon dont la forme générale est la suivante :

3
 si (condition) alors
instruction1
sinon
instruction2 ;

où instruction1 et instruction2 sont des instructions simples ou composées. Dans ce

dernier cas, la forme générale de la structure si…alors…sinon est :

si (condition) alors
début
instruction1 ;
instruction2 ;
…
instructionn ;
fin
sinon
début
instruction1 ;
instruction2 ;
…
instructionm ;
fin ;

Cette instruction s’exécute de la manière suivante :

1. La condition qui se trouve entre les mots réservés si et alors est évaluée.
2. Si elle a la valeur « vrai », on exécute l’instruction qui suit la clause alors et
l’exécution continue avec l’instruction suivante (celle qui suit l’instruction si).
Si elle a la valeur « faux », on exécute l’instruction qui suit la clause sinon et
l’exécution continue avec l’instruction suivante.

Notre algorithme peut maintenant s’écrire de la manière suivante :

algorithme Division2 ;
var
A, B : réel ;
Début
écrire('Quelle est la valeur du dividende ? ') ;
lire(A) ;
écrire('Quelle est la valeur du diviseur ? ') ;
lire(B) ;

4
 si B = 0 alors
Écrire('Division impossible')
sinon
Écrire(A, ' / ', B, ' = ', A/B) ;
fin.

algorithme salutation ;
var
nom : chaîne ;
marié : booléen ;
Ch : char ;
début
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Êtes-vous marié (O ou N) ? ') ;
lire(Ch) ;
si Ch = 'O' alors
marié  vrai
sinon
marié  faux ;
si marié alors
écrire(nom, 'est marié')
sinon
écrire(nom, 'est célibataire') ;
fin.

Conditions composées

Comme premier exemple d’algorithme impliquant des conditions composées,

considérons le problème qui consiste à lire trois nombres et à afficher le plus grand
de ces nombres.

algorithme max3;
var
a, b, c: réel;
début
écrire('Entrez les valeurs de a, b et c') ;
lire(a, b, c) ;
si (a  b) et (a  c) alors
écrire('Le plus grand est : ', a)
sinon

5
 si (b  a) et (b  c) alors
écrire('Le plus grand est : ', b)
sinon
écrire('Le plus grand est : ', c) ;
fin.

Le deuxième exemple porte sur la procédure de vérification de la position d’un

client. Lorsqu’un client veut faire un achat avec sa carte de crédit, le vendeur
détermine ce qu’il faut faire sur la base des informations suivantes : si l’achat ne
dépasse pas 100000 francs, le tabac ne fait pas partie des marchandises achetées et
l’acheteur a sur lui sa carte de crédit, alors l’achat est approuvé, sinon le vendeur
vérifie au niveau du département du crédit.

algorithme Vérification ;
var
montant : réel ;
tabac, carte : char ;
début
écrire('Quel est le montant des achats ? ') ;
lire(montant) ;
écrire('Possédez-vous votre carte de crédit (O ou N) ? ') ;
lire(Carte) ;
écrire('Avez-vous pris du tabac (O ou N) ? ') ;
lire(tabac) ;
si (montant < 100000) et (carte = 'O') et (tabac = 'N') alors
écrire('Achat approuvé')
sinon
écrire('Vérifier au niveau du département du crédit') ;
fin.

Exercices d’apprentissage

Exercice 2.1
Si une expression booléenne utilise des opérateurs logiques tels que ET et OU,
ainsi que des opérateurs relationnels, pourquoi doit on utiliser des parenthèses ?

Exercice 2.2

Autres exemples d’algorithmes

Exemple 1. Écrire un algorithme pour calculer le salaire hebdomadaire d’un

employé connaissant le taux horaire et le nombre d’heures de travail effectuées par

6
cet employé. Le salaire est calculé en utilisant le barème suivant : les quarante
premières heures de travail sont considérées comme des heures régulières et sont
payées au taux normal ; les heures au-dessus des quarante premières heures sont
considérées comme des heures complémentaires et sont payées une fois et demie le
taux horaire.

algorithme Paie ;
var
HoursWorked, TauxHoraire : réel ;
Overtime, Régulier : réel ;
Salaire : réel ;
début
écrire('Heures effectuées : ')
lire(HoursWorked) ;
écrire('Taux horaire : ')
lire(TauxHoraire) ;
si (HoursWorked > 40.0) alors
Overtime  HoursWorked – 40.0
sinon
Overtime  0 ;
Régulier  HoursWorked – Overtime ;
Salaire  Régulier * Taux + Overtime * TauxHoraire * 1.5 ;
Écrire('Salaire : ', Salaire) ;
fin.

Exemple 2. Écrire un algorithme qui lit trois nombres réels et détermine si ces
nombres constituent les côtés d’un triangle rectangle.

algorithme TriangleRectangle ;
var
a, b, c : entier ;
début
écrire('Quelles sont les valeurs de a, b et c ? ')
lire(a, b, c) ;
si (a*a + b*b = c*c) ou (a*a + c*c = b*b) ou (b*b + c*c = a*a) alors
Écrire('Les nombres forment un triangle rectangle')
sinon
Écrire('Les nombres ne forment pas un triangle rectangle') ;
fin.

La structure si…alors

7
Comme nous l’avons vu, la construction si…alors…sinon est utilisée pour choisir
laquelle de deux instructions on doit exécuter sur la base de la valeur de vérité
d’une expression logique. Toutefois, l’instruction de sélection peut aussi être
utilisée sans la clause sinon. Dans ce cas, on parlera de la structure si…alors dont
la forme générale est la suivante :

si (condition) alors
instruction ;

où instruction est une instruction simple ou composée. Dans ce dernier cas, on a :

si (condition) alors
début
instruction1 ;
instruction2
…
instructionn ;
fin ;

L’instruction si … alors est utile lorsqu’on veut effectuer une action si une certaine
condition est vraie et ignorer simplement cette action si la condition est fausse.
Dans ce cas, la clause sinon est superflue et peut être omise. Par exemple,
considérons une autre version de l’algorithme de paie ci-dessus.

algorithme Paie2 ;
var
HoursWorked, TauxHoraire : réel ;
Overtime, Régulier, Salaire : réel ;
début
écrire('Heures effectuées : ')
lireln(HoursWorked) ;
écrire('Taux horaire : ')
lireln(TauxHoraire) ;
Overtime  0 ;
si (HoursWorked > 40.0) alors
Overtime  HoursWorked – 40.0;
Régulier  HoursWorked – Overtime ;
Salaire  Régulier * TauxHoraire + Overtime * TauxHoraire * 1.5 ;
Écrire('Salaire : ', Salaire) ;
fin.

8
On commence par initialiser Overtime à zéro, ensuite on vérifie si l’employé a
effectué plus de 40 heures de travail. Si l’employé a effectué plus de 40 heures, on
calcule Complémentaire sinon on ne fait rien. Quel que soit le résultat, on calcule
ensuite le nombre d’heures complémentaires effectuées par l’employé et enfin on
calcule le salaire de ce dernier. Comparer cet algorithme avec la version précédente
où on utilise la construction si … alors … sinon pour contrôler l’ordre
d’exécution.

Les instructions de sélection imbriquées

On parle d’instructions de sélection imbriquées lorsque dans une instruction

si…alors ou si…alors…sinon, l’instruction qui suit la clause alors ou la clause
sinon est elle-même une instruction de sélection. Les instructions de sélection
imbriquées permettent de tester des conditions en cascade afin de déterminer
l’instruction ou le groupe d’instructions qui doit être exécuté. Considérons par
exemple le problème qui consiste à lire deux nombres entiers et imprimer le plus
grand de ces deux nombres. Si les deux nombres sont égaux, on imprime le
message « Les deux nombres sont égaux ». Un algorithme pour faire cela est le
suivant :

algorithme Compare ;
var
x, y : entier ;
début
lire(x) ;
lire(y) ;
si (x > y) alors
écrire ('Le plus grand nombre est : ', x)
sinon
si (x = y) alors
écrire('Les deux nombres sont égaux')
sinon
écrire('Le plus grand nombre est : ', y)
fin.

Un examen de cet algorithme nous amène à remarquer que nous avons eu besoin
d’utiliser une structure de sélection qui se traduit par deux instructions
si…alors…sinon écrites en cascade. Il s’agit en réalité d’une seule instruction
si…alors…sinon dans laquelle l’instruction qui suit la clause sinon est elle-même
une instruction si…alors…sinon. On dira alors que l’on a à faire à des instructions
si…alors…sinon imbriquées.

9
L’instruction de sélection multiple

Les conditions composées sont particulièrement utiles dans les situations où on a

besoins de tester plusieurs conditions pour décider laquelle de deux instructions on
doit effectuer. Lorsqu’on doit choisir entre plusieurs instructions, on peut souvent
utiliser l’instruction à choix multiples. Cette instruction prend la forme générale :

case (expression) de
liste-valeurs1 : instruction1 ;
liste-valeurs2 : instruction2 ;
.
.
.
liste-valeursn : instructionn ;
fin;

L’expression comprise entre les mots réservés case et de est l’expression de

sélection. C’est la valeur prise par cette expression qui détermine l’instruction qui
doit être exécutée. liste-valeurs1, …, liste-valeurs1 énumèrent les différentes
valeurs que peut prendre l’expression de sélection.

Considérons par exemple l’ensemble d’instructions « si » imbriquées suivant.

si (opération = 1) alors
CA+B
sinon
si (opération = 2) alors
CA–B
sinon
si (opération = 3) alors
C  A div B
sinon
si (opération = 4) alors
CA*B;

En utilisant une instruction de sélection multiple, nous pouvons réécrire cette

instruction de la manière suivante :

case (opération) de
1:CA+B;
2:CA–B;
3 : C  A div B;

10
 4:CA*B;
fin ;

Quand on exécute une instruction de sélection multiple, l’expression de sélection

est évaluée. Dans notre exemple, la variable code est l’expression de sélection. La
valeur de l’expression de sélection doit être égale à l’une des valeurs énumérées
dans le corps de l’instruction. L’instruction qui sera exécutée est celle qui
correspond à la liste dans laquelle se trouve la valeur de l’expression de sélection.
Si la valeur de l’expression de sélection ne se trouve dans aucune des listes, aucune
instruction ne sera exécutée. Pour prendre en compte ce genre de situations, on
peut ajouter une clause sinon dans une instruction de sélection multiple pour
spécifier une instruction qui prendre en charge ces cas particuliers.

case (expression) de
liste-valeurs1 : instruction1 ;
liste-valeurs2 : instruction2 ;
.
.
.
liste-valeursn : instructionn ;
sinon
autre-instruction ;
fin ;

On peut aussi utiliser la convention suivante : pour prévoir que l’expression de

sélection puisse prendre une valeur différente de toutes des valeurs attendues, on
introduit une étiquette spéciale, que nous appellerons par convention défaut, qui
sera la valeur par défaut de l’expression de sélection lorsque sa valeur effective ne
sera pas égale à l’une quelconque des étiquettes listées.

case (expression) de
liste-valeurs1 : instruction1 ;
liste-valeurs2 : instruction2 ;
.
.
.
liste-valeursn : instructionn ;
défaut : autre-instruction ;
fin ;

L’instruction de sélection multiple peut aussi être utilisée dans les situations où on
travaille avec un grand nombre de valeurs possibles. Par exemple, une mention est
attribuée à un étudiant sur la base du barème suivant :

11
 Mention Note inférieure
A 90
B 80
C 70
D 60
E inférieur à 60

On peut penser au premier abord que l’on doit lister toutes les valeurs possibles des
notes (on suppose que les notes varient de 0 à 100) dans les étiquettes. Cependant,
ceci n’est pas nécessaire. On peut réduire considérablement le nombre d’étiquettes
nécessaires en utilisant la division euclidienne par 10, ce qui permet de ne plus
considérer que le reste de la division euclidienne de la note par 10.
L’algorithme ci-dessous lit une note et affiche la mention correspondante en
utilisant une instruction de sélection multiple.

algorithme Mention ;
var
note : entier ;
début
écrire('Quelle est la note ? ') ;
lire(note) ;
si (note < 0) ou (note > 100) alors
Écrire('Mauvaise donnée')
sinon
case (note div 10) de
10, 9 : Écrire('A') ;
8 : Écrire('B') ;
7 : Écrire('C') ;
6 : Écrire('D') ;
5, 4, 3, 2, 1, 0 : Écrire('F') ;
fin ;
fin.

On peut réécrire cet algorithme en utilisant des instructions si … alors … sinon

imbriquées. L’algorithme devient alors :

algorithme Mention ;
var
note : entier ;
début
écrire('Quelle est la note ? ') ;
lire(note) ;

12
 si (note < 0) ou (note > 100) alors
Écrire('Mauvaise donnée')
sinon
si note < 60 alors
Écrire('F')
sinon
si note < 70 alors
Écrire('D')
sinon
si note < 80 alors
Écrire('C')
sinon
si note < 90 alors
Écrire('B')
sinon
Écrire('A') ;
fin.

13
Exercices d’apprentissage

Exercice 2.4
Les longueurs des côtés d’un triangle sont stockées dans les variables réelles a, b et
c. Pour que a, b et c soient effectivement correctes, la somme de deux quelconque
des trois nombres doit être strictement supérieure au troisième. Écrire un
algorithme qui lit trois nombres réels a, b et c et détermine si a, b et c sont
effectivement les côtés d’un triangle. Si oui, alors écrire le message « Triangle »
dans le cas contraire écrire le message « Pas un triangle ».

Exercice 2.5
Une année est bissextile si son millésime est un multiple de 4, sauf les années de
début de siècle qui sont bissextiles si leur millésime est divisible par 400. Écrire un
algorithme qui lit un entier naturel et détermine si cet entier représente une année
bissextile.

Exercice 2.6
Une boulangerie est ouverte de 7 heures à 13 heures et de 16 heures à 19 heures,
sauf le dimanche après-midi et le lundi toute la journée. Écrire un algorithme qui lit
une heure (un entier naturel) et un jour (une chaîne de caractère) et détermine si la
boulangerie est ouverte le jour et à l’heure indiqués.

Exercice 2.7
Un entier positif est stocké dans une variable nombre. Utiliser une instruction de
sélection multiple pour imprimer un message indiquant si le nombre est paire ou
impaire.

Exercice 2.8
Écrire un programme pour résoudre le système d’équations linéaires d’inconnues x
et y :

Ax + By = C
Dx + Ey = F

Exercice 2.9
Écrire un algorithme qui lit un nombre représentant l’âge d’une personne et affiche
le message « vous êtes mineur » si son âge est inférieur à 18 ans et le message
« vous êtes majeur » dans le cas contraire.

Exercice 2.10
Écrire un algorithme qui lit le nom et le sexe d’une personne et affiche le message
« Bonjour, Monsieur … » si la personne est de sexe masculin et le message
« Bonjour, Madame … » si la personne est de sexe féminin.

14
Exercice 2.11
Écrire un algorithme qui le nom, le sexe et le statut matrimonial d’une personne et
affiche le message « Bonjour monsieur … » si la personne est de sexe masculin, le
message « Bonjour mademoiselle … » si la personne est une demoiselle et le
message « Bonjour madame … » si la personne est une dame.

Exercice 2.12
Écrire un algorithme qui lit trois nombres et imprime le plus grand des trois
nombres.

Exercice 2.13
Écrire un algorithme qui lit quatre nombres et imprime le plus grand des quatre
nombres.

Exercice 2.14
Écrire un algorithme qui lit deux nombres réels A et B puis calcule la solution
réelle de l’équation Ax + B = 0.

Exercice 2.15
Écrire un algorithme qui lit trois nombres réels a, b et c puis calcule les solutions
réelles de l’équation quadratique ax 2  bx  c  0 .

Exercice 2.16
Les tarifs d’affranchissement d’une lettre sont les suivants :
en-dessous de 20g : 280 FCFA,
à partir de 20g, mais en-dessous de 50g : 440 FCFA,
à partir de 50g : 670 FCFA.
Écrire un algorithme qui lit le poids d’une lettre et imprime le montant de
l’affranchissement de la lettre.

Exercice 2.18
On souhaite calculer le montant des impôts dus par un contribuable en fonction son
revenu imposable et de son nombre de parts fiscales. Les règles de calcul sont les
suivantes :
 le revenu par part fiscale est égale au quotient du revenu imposable par le
nombre de parts fiscales
 l’impôt par part fiscale est calculé selon le barème suivant :
 0 si le revenu par part fiscale est inférieur à 50000 F ;
 10% sur la tranche du revenu par part fiscale comprise entre 50000
F et 100000 F ;
 25% sur la tranche du revenu par part fiscale comprise entre
100000 F et 200000 F ;

15
  50% sur le revenu par part fiscale est qui dépasse 200000 F
 l’impôt total est égal au nombre de parts fiscales multiplié par l’impôt par
part fiscale.

Écrire un algorithme qui lit le revenu imposable et le nombre de parts fiscales d’un
contribuable puis calcule le montant des impôts dus par ce contribuable.

16
4. La structure de répétition

4.1 Le concept de boucle

Les algorithmes que nous avons écrits jusque là ont une caractéristique
commune : ils ne peuvent traiter qu’un seul ensemble de données pour une
exécution donnée. Considérons par exemple l’algorithme de bonjour personnalisé
suivant :

algorithme bonjour ;
var
nom : chaîne ;
début
écrire(‘Quel est votre nom ?’) ;
lire(nom) ;
écrire(‘Bonjour’, nom) ;
fin.

Cet algorithme ne peut imprimer le message de bonjour personnalisé que pour

une seule personne au cours d’une exécution donnée. Si vous imprimer ce message
pour plusieurs personnes, on devra reprendre l’exécution du programme autant de
fois que nécessaire. Nous serions plus à l’aise si nous avions la possibilité de
communiquer à la machine les informations sur la liste des employés dont on veut
calculer les salaires, et laisser le programme traiter automatiquement toute la liste.
En un mot, on aimerait que toutes ou certaines actions de l’algorithme soient
exécutées plus d’une fois, mais avec des données différentes.

Une instruction ou un ensemble d’instructions qui est exécuté plusieurs fois, de

façon répétitive, dans un algorithme est constitue une boucle. Nous pouvons donc
définir une boucle comme une instruction ou une séquence d’instructions que l’on
veut exécuter une ou plusieurs fois.

Nous avons souvent besoin d’utiliser les boucles dans des algorithmes pour
deux raisons principales :

 On a besoin de répéter les mêmes opérations sur des données différentes,

 On a besoin de répéter un ensemble d’opérations pour résoudre un
problème.

La situation que nous avons décrite avec l’algorithme de calcul de la paie des
employés tombe dans la première catégorie. On est intéressé par la répétition des
opérations qui consistent à lire le taux horaire et le nombre d’heures de travail
effectuées par un employé, à calculer et à imprimer son salaire. On rencontrera

17
dans la suite des exemples de la deuxième catégorie où on commence avec une
seule valeur et on répète un ensemble de calculs jusqu’à ce que l’on obtienne le
résultat désiré.

On distingue deux formes de boucles : les boucles conditionnelles ou

indéterminées et les boucles contrôlées par un compteur. Une boucle
conditionnelle est répétée tant que ou jusqu’à ce qu’une certaine condition soit
vraie. Une boucle contrôlée par un compteur est répétée un nombre de fois fixé
d’avance, les itérations étant comptées par une variable de contrôle.

Les boucles conditionnelles

Le langage algorithmique offre trois instructions différentes que nous pouvons

utiliser pour exprimer les boucles conditionnelles, à savoir :
 l’instruction répéter…jusquà (repeat …until)
 l’instruction tanque…faire (while…do)
 l’instruction faire…tantque (do…while)

Pour illustrer ces trois instructions, nous allons nous baser sur l’exemple
suivant. Supposons que l’on veuille écrire un algorithme pour calculer la moyenne
de dix nombres. Une première version de l’algorithme qui permet de résoudre ce
problème se présente de la manière suivante :

début
Lire dix nombres
Calculer la moyenne des dix nombres
Écrire la moyenne
fin.

Exprimé de cette manière, cet algorithme nécessiterait que l’on déclare dix
variables, une pour chacun des nombres dont on veut calculer la moyenne, lire
d’abord les valeurs des dix variables, calculer ensuite leur moyenne et imprimer le
résultat pour terminer. Cette approche n’est pas seulement non nécessaire, mais
elle peut devenir intolérable si on tente de généraliser cet algorithme pour calculer
la moyenne de mille nombres par exemple.

Une meilleure approche consiste à prendre avantage du fait que l’on n’a pas
besoin que tous les nombres soient disponibles en même temps. Tout ce que nous
voulons faire c’est de conserver un total courant des nombres dont on veut calculer
la moyenne. Pour calculer la moyenne, on divise le total final par le nombre de
valeurs que l’on a. Ceci suggère que l’on lise un nombre à la fois et que l’on ajoute

18
ce nombre au total courant jusqu’à ce que tous les nombres soient lus. Ensuite on
divise le total par dix pour obtenir la moyenne.

Pour s’assurer que tous les nombres sont effectivement lus et que le total est
correctement calculé, on utilise deux variables :
 une variable appelée total dont le rôle cumuler la somme des nombres au
fur et mesure qu’ils sont lus. Au départ, total est initialisé à zéro ;
 une variable appelée compteur dont le rôle est de compter les nombres au
fur et mesure de leur lecture. Au départ, compteur est initialisé à zéro.

Notre algorithme peut maintenant avoir la forme suivante :

début
initialiser total à zéro
initialiser compteur à zéro
répéter
lire un nombre
ajouter le nombre au total
incrémenter le compteur
jusquà (compteur = 10) ;
calculer la moyenne
imprimer la moyenne
fin.

Dans cet algorithme, la boucle conditionnelle est exprimée en délimitant les

instructions à répéter par les mots réservés répéter et jusquà. Cet algorithme
spécifie que les trois instructions,

lire un nombre
ajouter le nombre au total
incrémenter le compteur

doivent être répétées jusqu’à ce que la condition « compteur = 10 » prenne la

valeur « vrai ». Ces trois instructions constituent le corps de la boucle et la boucle
se termine lorsque la condition « compteur = 10 » prend la valeur « vrai ».

a) L’instruction répéter…jusquà

La première instruction que l’on peut utiliser pour exprimer une boucle
conditionnelle est l’instruction répéter…jusquà dont la forme générale est :

répéter
instruction

19
 jusquà (condition) ;

où instruction est une instruction simple ou composée. Dans ce dernier cas, la

boucle répéter …jusquà prend la forme générale :

répéter
instruction1 ;
instruction2 ;
…
instructionn ;
jusquà (condition) ;
La condition qui suit le mot réservé jusquà est appelée la condition de
terminaison de la boucle car cette dernière se termine lorsque cette condition
prend la valeur « vrai ».

L’instruction répéter … jusquà s’exécute de la manière suivante :

1. Le corps de la boucle est exécuté, puis ;

2. La condition de terminaison de la boucle est évaluée. Si elle a la valeur
« vrai », la boucle est terminée et l’exécution continue avec l’instruction qui
suit la boucle. Si elle a la valeur « faux », on reprend l’exécution du corps de
la boucle.

Les mots réservés répéter et jusquà sont utilisés pour délimiter le corps de la
boucle. Ainsi, les instructions de la boucle constituent une instruction composée.
Ceci est un exemple d’instruction composée où on n’utilise pas début et fin pour
regrouper les instructions

On peut exprimer le fonctionnement de la boucle répéter…jusquà à l’aide de

l’organigramme suivant :

Corps de la boucle

F V
Condition

20
Remarques
 La boucle ne se terminera jamais si la condition de terminaison reste
indéfiniment fausse. Il est donc important que le corps de la boucle
contienne au moins une instruction de mise à jour de la condition de
terminaison pour garantir que celle-ci deviendra vraie après un nombre fini
d’étapes.

 Une propriété importante de la boucle répéter…jusquà est que le corps de

la boucle est exécuté au moins une fois. Ceci est vrai parce que la condition
de terminaison est testée à la sortie de la boucle.

Nous pouvons donc maintenant écrire l’algorithme de calcul de la moyenne de 10

nombres de la manière suivante :

algorithme moyenne ;
var
nombre, total, moy : réel ;
i : entier ;
début
i0;
total  0 ;
répéter
lire(nombre) ;
total  total + nombre ;
i  i +1 ;
jusquà (i = 10) ;

moy  total/10.0 ;
écrire('La moyenne est : ', moy) ;
fin.

Autres exemples

Exemple 1. Écrire un algorithme pour lire les noms d’une liste de 10 personnes et
imprimer à chaque fois le message « Bonjour … ».

algorithme Bonjour ;
var
nom : chaîne ;
i : entier ;
début

21
 i0;
répéter
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Bonjour', nom) ;
ii+1;
jusquà (i = 10) ;
fin.

Exemple 2. Écrire un algorithme pour résoudre une série de dix équations de la

forme ax + b = 0, où a et b sont des nombres réels.

algorithme Equation ;
var
a, b, x : reels ;
i : entier ;
début
i0;
répéter
écrire('Quel est la valeur de a ? ') ;
lire(a) ;
écrire('Quel est la valeur de b ? ') ;
lire(b) ;
ii+1;
si (a  0) alors
debut
x  -b/a ;
écrire('La solution est : ', x)
fin
sinon
si (b = 0) alors
écrire('Équation indéterminée')
sinon
écrire('Équation impossible') ;
jusquà (i = 10) ;
fin.

Exemple 3. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus grand de ces nombres.

L’approche consiste à traiter un nombre à la fois et garder trace de la plus grande

valeur déjà rencontrée. Chaque nouvelle valeur lue est comparée à la plus grande
valeur courante. Si elle est plus grande, elle devient le nouveau plus grand. Si elle

22
est inférieure à la plus grande valeur courante, on conserve la plus grande valeur
courante et on lit la valeur suivante. Au départ la plus grande valeur courante est
initialisée au premier nombre lu.

algorithme maxliste ;
var
nombre, grand : real ;
i : entier ;
début
i1;
lire(nombre) ;
grand  nombre ;
répéter
lire(nombre) ;
ii+1;
si (nombre > grand) alors
grand  nombre ;
jusquà (i = 100) ;
écrire('Le plus grand nombre est : ', grand) ;
fin.

Exemple 4. Écrire un algorithme pour lire une suite de 100 nombres réels et
déterminer le plus petit de ces nombres.

algorithme minliste ;
var
nombre, min : real ;
i : entier ;
début
i1;
lire(nombre) ;
min  nombre ;
répéter
lire(nombre) ;
ii+1;
si (nombre < min) alors
min  nombre ;
jusquà (i = 100) ;
écrire('Le plus petit nombre est : ', min) ;
fin.

23
Exemple 5. Écrire un algorithme pour lire une suite de 100 nombres réels et
déterminer le plus petit et le plus grand de ces nombres.

algorithme maxmiliste ;
var
nombre, min, max : real ;
i : entier ;
début
i1;
lire(nombre) ;
min  nombre ;
max  nombre ;
répéter
lire(nombre) ;
ii+1;
si (nombre < min) alors
min  nombre ;
si (nombre > max) alors
max  nombre ;
jusquà (i = 100) ;

écrire('Le plus petit nombre est : ', min) ;

écrire('Le plus grand nombre est : ', max) ;
fin.

Exemple 6. Écrire un algorithme pour lire une suite de 100 nombres réels et
déterminer le plus petit de ces nombres ainsi que sa position dans la liste. On
envisagera le cas de la première occurrence et le cas de la dernière occurrence.

Algorithme posminliste ;
variable
nombre, min : real ;
i, indice : entier ;
début
i1;
lire(nombre) ;
indice  1 ;
min  nombre ;
répéter
lire(nombre) ;
ii+1;
si nombre < min alors

24
 début
min  nombre ;
indice  i ;
fin ;
jusquà (i = 100) ;
écrire('Le plus petit nombre est : ', min) ;
écrire('Sa position dans la liste est : ', indice) ;
fin.

Exemple 7. Écrire un algorithme pour traiter une liste de 10 étudiants. Pour chaque
étudiant l’algorithme lit le nom de l’étudiant, sa note de contrôle continu et sa note
de synthèse dans une certaine unité de valeur, calcule la moyenne de l’étudiant et
affiche le message «… a pour moyenne :…). La note de contrôle continu compte
pour 30% et la note de synthèse pour 70%.

algorithme gestionote ;
var
nom : chaîne ;
note1, note2, moyenne : real ;
n: entier ;
début
n0;
répéter
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Votre note de contrôle continu ? ') ;
lire(note1) ;
écrire('Votre note de synthèse ? ') ;
lire(note2) ;
moyenne  0.3*note1 + 0.7*note2 ;
nn+1;
écrire(nom, 'a pour moyenne : ', moyenne);
jusquà (n = 10) ;
fin.

Exemple 8. Écrire un algorithme pour calculer les salaires hebdomadaires de n

employés temporaires. Pour chaque employé, le programme demande le nom, le
taux horaire et le nombre d’heures de travail effectuées, puis calcule le salaire de
l’employé. Les règles suivantes sont utilisées pour calculer le salaire d’une
employé. Les 40 premières heures sont considérées comme des heures régulières et
payées au taux normal. Les heures effectuées au delà des 40 premières heures sont
considérées comme des heures complémentaires et payées une fois et demie le taux
horaire.

25
Algorithme Paie ;
variable
nom : chaîne ;
Rate, HoursWorked : réel ;
Salary, Regular, Overtime : réel ;
i, n: entier ;
début
écrire('Nombre employés :') ;
lire(n) ;
i0;
répéter
écrire('Nom employé :') ;
lire(nom) ;
écrire('Taux horaire : ') ;
lire(Rate) ;
écrire('Heures effectuées : ') ;
lire(HoursWorked) ;
ii+1;
si HoursWorked > 40 alors
Overtime  HoursWorked – 40.0
sinon
Overtime  0 ;

Regular  HoursWorked – Overtime ;

Salary  Rate * Regular + 1.5*Rate*Overtime ;
écrire('Nom :', Nom) ;
écrire('Salaire : ', Salary);
jusquà (i = n) ;
fin.

b) L’instruction faire…tantque

Une autre instruction très proche de l’instruction répéter…jusquà que nous

pouvons utiliser dans une boucle conditionnelle est l’instruction faire…tantque
dont la forme générale est :

faire
instruction
tantque (condition) ;

où instruction est une instruction simple ou composée. Dans ce dernier cas, la

boucle faire…tantque prend la forme générale

26
 faire
instruction1 ;
instruction2 ;
…
instructionn ;
tantque (condition) ;

La condition qui suit le mot réservé tantque est appelée la condition de répétition
de la boucle car la boucle continue tant que cette condition a la valeur « vrai ».

La boucle faire…tantque s’exécute de la manière suivante :

1. Le corps de la boucle est exécuté, puis ;

2. La condition de répétition est évaluée. Si elle a la valeur faux, la boucle est
terminée et l’exécution continue avec l’instruction suivante. Si elle a la
valeur vrai, on reprend l’exécution du corps de la boucle.

Nous pouvons illustrer le fonctionnement de l’instruction faire…tantque à l’aide

de l’organigramme suivant :

Corps de la boucle

V F
Condition

Remarques
 La boucle ne se terminera jamais si la condition de répétition reste
indéfiniment vraie. Il est donc important que le corps de la boucle contienne
au moins une instruction de mise à jour de la condition de répétition pour
garantir que celle-ci deviendra fausse après un nombre fini d’étapes.
 Une propriété importante de la boucle faire…tantque est que le corps de la
boucle est exécuté au moins une fois. Ceci est vrai parce que la condition de
répétition est testée à la sortie de la boucle.

L’algorithme de calcul de la moyenne peut donc s’écrire de la manière suivante en

utilisant la boucle faire…tantque.

27
algorithme moyliste ;
variable
nombre, total, moy : réel ;
nb : entier ;
début
nb  0 ;
total  0 ;
faire
écrire(‘Entrez un nombre :’) ;
lire(nombre) ;
total  total + nombre ;
nb  nb +1 ;
tantque (nb < 10) ;

moyenne  total/10 ;
écrire('La moyenne est : ', moy) ;
fin.

Exercice 3.1
Généraliser l’algorithme ci-dessus pour lire une suite de n nombres et calculer la
moyenne de ces n nombres ; le nombre n de nombres devant être lu dans
l’algorithme.

Autres exemples

Exemple 1. Écrire un algorithme pour lire les noms d’une liste de 10 personnes et
écrire à chaque fois le message « Bonjour … ».

algorithme Bonjour ;
var
nom : chaîne ;
i : entier ;
début
i0;
faire
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Bonjour', nom) ;
ii+1;
tantque (i < 10) ;
fin.

28
Exemple 2. Écrire un algorithme pour résoudre une suite de 10 équations de la
forme ax + b = 0, où a et b sont des nombres réels.

algorithme Equation ;
var
a, b, x : real ;
i : entier ;
début
i0;
faire
écrire('Quel est la valeur de a ? ') ;
lire(a) ;
écrire('Quel est la valeur de b ? ') ;
lire(b) ;
ii+1;
si (a  0) alors
début
x  -b/a ;
écrire('La solution est : ', x)
fin
sinon
si b = 0 alors
écrire('Équation indéterminée')
sinon
écrire('Équation impossible') ;
tantque (i < 10) ;
fin.

Exemple 3. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus grand de ces nombres.

L’approche consiste à traiter un nombre à la fois et garder trace de la plus grande

valeur déjà rencontrée. Chaque nouvelle valeur lue est comparée à la plus grande
valeur courante. Si elle est plus grande, elle devient le nouveau plus grand. Si elle
est inférieure à la plus grande valeur courante, on conserve la plus grande valeur
courante et on lit la valeur suivante. Au départ la plus grande valeur courante est
initialisée au premier nombre lu.

algorithme maxliste ;
var
nombre, grand : real ;
i : entier ;
début

29
 i1;
écrire(‘Entrez un nombre :’) ;
lire(nombre) ;
grand  nombre ;
faire
écrire(‘Entrez un nombre :’) ;
lire(nombre) ;
ii+1;
si (nombre > grand) alors
grand  nombre ;
tantque (i < 100) ;
écrire('Le plus grand nombre est : ', grand) ;
fin.

Exemple 4. Généraliser l’algorithme ci-dessus pour qu’il lise une suite de n

nombres et détermine le plus grand de ces n nombres ; le nombre n de nombres
devant être lu dans l’algorithme.

algorithme maxliste ;
var
nombre, grand : réel ;
n, i : entier ;
début
écrire('Quelle est la valeur de n ?') ;
lire(n) ;
si (n  0) alors
écrire('Valeur positive attendue ! ')
sinon
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
i1;
grand  nombre ;
faire
écrire(‘Entrez un nombre :’) ;
lire(nombre) ;
ii+1;
si (nombre > grand) alors
grand  nombre ;
tantque (i < n) ;
écrire ('Le plus grand nombre est : ', grand) ;
fin ;

30
fin.

Exemple 5. Écrire un algorithme pour lire une suite de 100 nombres réels et
déterminer le plus petit de ces nombres.

algorithme minliste ;
var
nombre, min: réel ;
i : entier ;
début
i1;
écrire('Entrez un nombre : ') ;
lire(nombre) ;
min  nombre ;
faire
écrire('Entrez un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre < min) alors
min  nombre ;
tantque (i < 100) ;
écrire('Le plus petit nombre est : ', min) ;
fin.

Exemple 6. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus petit et le plus grand de ces nombres.

algorithme maxminliste ;
var
nombre, min, max : réel ;
i : entier ;
début
i1;
écrire('Entre un nombre : ') ;
lire(nombre) ;
min  nombre ;
max  nombre ;
faire
écrire('Entrez un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre < min) alors

31
 min  nombre ;
si (nombre > max) alors
max  nombre ;
tantque (i < 100) ;

écrire('Le plus petit nombre est : ', Min) ;

écrire('Le plus grand nombre est : ', Max) ;
fin.

Exemple 7. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus petit de ces nombres ainsi que sa position dans la liste. On envisagera le cas
de la première occurrence et le cas de la dernière occurrence.

algorithme posminliste ;
var
nombre, min : réel ;
i, indice : entier ;
début
i1;
écrire('Entrez un nombre : ') ;
lire(nombre) ;
indice  1 ;
min  nombre ;
faire
écrire('Entre un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre < min) alors
début
min  nombre ;
indice  i ;
fin ;
tantque (i < 100) ;
écrire('Le plus petit nombre est : ', min) ;
écrire('Sa position dans la liste est : ', indice) ;
fin.

Exemple 8. Écrire un algorithme pour traiter une liste de 10 étudiants. Pour chaque
étudiant l’algorithme lit le nom de l’étudiant, sa note de contrôle continu et sa note
de synthèse dans une certaine unité de valeur, calcule la moyenne de l’étudiant et
affiche le message «… a pour moyenne :…). Le note de contrôle continu compte
pour 30% et la note de synthèse pour 70%.

32
algorithme gestionote;
var
nom : chaîne ;
note1, note2, moyenne : real ;
nb : entier ;
début
nb  0 ;
faire
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Votre note de contrôle continu ? ') ;
lire(note1) ;
écrire('Votre note de synthèse ? ') ;
lire(note2) ;
moyenne  0.3*note1 + 0.7*note2 ;
nb  nb + 1 ;
écrire(nom, 'a pour moyenne : ', moyenne);
tantque (nb < 10) ;
fin.

Exemple 8. Écrire un algorithme pour calculer les salaires hebdomadaires de n

employés temporaires. Pour chaque employé, le programme demande le nom, le
taux horaire et le nombre d’heures de travail effectuées, puis calcule le salaire de
l’employé. Les règles suivantes sont utilisées pour calculer le salaire d’une
employé. Les 40 premières heures sont considérées comme des heures régulières et
payées au taux normal. Les heures effectuées au delà des 40 premières heures sont
considérées comme des heures complémentaires et payées une fois et demie le taux
horaire.

algorithme Paie ;
var
nom : chaîne ;
Rate, HoursWorked, Salary : réel ;
Regular, Overtime : réel ;
i, n : entier ;
début
écrire('Nombre employés :') ;
lire(n) ;
i0;
faire
écrire('Nom employé : ') ;
lire(nom) ;

33
 écrire('Taux horaire : ') ;
lire(Rate) ;
écrire('Heures effectuées : ') ;
lire(HoursWorked) ;
ii+1;
si (HoursWorked > 40) alors
Overtime  HoursWorked – 40.0
sinon
Overtime  0 ;
Regular  HoursWorked – Overtime ;
Salary  Rate * Regular + 1.5*Rate*Overtime ;
écrire('Nom : ', nom) ;
écrire('Salaire : ', Salary);
tantque (i < n) ;
fin.

c) La structure tantque … faire

La troisième instruction que nous pouvons utiliser pour exprimer une boucle
conditionnelle est l’instruction tantque…faire dont la forme générale est :

tantque (condition) faire

instruction ;

où instruction est une instruction simple ou composée. Dans ce dernier cas,

l’instruction tanque … faire prend la forme générale :

tantque (condition) faire

début
instruction1 ;
instruction2 ;
...
instructionn ;
fin ;

L’instruction simple ou composée qui suit le mot réservé faire constitue le corps
de la boucle. La condition entre les mots réservés tantque et faire est la condition
de répétition de la boucle.

L’instruction tantque … faire s’exécute de la manière suivante :

1. On évalue la condition de répétition de la boucle.

34
 2. Si elle a la valeur vrai, on exécute le corps de la boucle et on recommence à
l’étape 1. Si elle a la valeur faux, on quitte la boucle et l’exécution continue
avec l’instruction qui suit la boucle tantque …faire.

Nous pouvons illustrer le fonctionnement de la boucle tantque…faire à l’aide de

l’organigramme suivant :

F
Condition
V

Corps de la boucle
Comme dans le cas des instructions répéter…jusquà et faire…tantque, la boucle
tantque …faire ne se terminera jamais si la condition de répétition reste
indéfiniment vraie. Il est donc important que le corps de la boucle contienne au
moins une instruction de mise à jour de la condition de terminaison pour garantir
que celle-ci deviendra fausse après un nombre fini d’étapes.

Remarque. Au contraire des instructions répéter…jusquà et faire…tantque, la

condition de répétition de l’instruction tantque…faire est évaluée à l’entrée de la
boucle plutôt qu’à la sortie. Ainsi, la corps d’une boucle tantque...faire peut ne
pas être exécutée du tout. Cela arrive lorsque la condition de répétition est
initialement fausse. Dans ce cas le corps de la boucle est tout simplement ignoré et
l’exécution continue avec l’instruction suivante. L’expression logique dans une
instruction répéter…jusquà ou dans une instruction faire…tantque est une
condition de terminaison tandis que l’expression logique dans une instruction
tantque… faire est une condition de répétition. Les codes ci-dessous illustrent
cette différence.

(*Multiplier les entiers de 1 à 10*)

produit  1 ;
i1;
répéter
produit  produit * i ;
ii+1;
jusquà (i > 10) ;

En réécrivant la boucle répéter…jusquà ci-dessus comme une boucle

tantque…faire, on obtient :

35
 (*Multiplier les entiers de 1 à 10*)
produit  1 ;
i1;
tantque (i  10) faire
début
produit  produit * i ;
ii+1;
fin ;

En général, une boucle conditionnelle peut être exprimée soit par une instruction
répéter…jusquà, soit par une instruction faire…tantque, soit par une instruction
tanque…faire. La plupart des langages de programmation implémentent une ou
deux de ces instructions. L’avantage d’avoir les différentes variantes est que ceci
permet d’utiliser celle qui semble la plus appropriée pour un problème particulier.
Réécrivons maintenant notre algorithme de calcul de la moyenne de 10 nombres en
utilisant la boucle tantque … faire. Dans ce cas particulier, aucune des
instructions n’est plus appropriée que les autres. Cependant, dans plusieurs
applications la boucle tantque … faire est plus appropriée que les deux autres
variantes parce qu’elle autorise que le corps de la boucle ne soit pas exécuté du
tout.

algorithme moyliste ;
var
nombre, total, moyenne : réel ;
i : entier ;
début
(*Initialisation de compteur et total*)}
i0;
total  0 ;
tantque i < 10 faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
total  total + nombre ;
ii+1;
fin ;
(*Calculer et écrire la moyenne*)
moyenne  total/10.0 ;
écrire('La moyenne est : ', moyenne) ;
fin.

Autres exemples

36
Exemple 1. Écrire un algorithme pour lire les noms d’une liste de 10 personnes et
imprimer à chaque fois le message « Bonjour … ».

algorithme Bonjour ;
var
nom : chaîne ;
i : entier ;
début
i0;
tantque (i < 10) faire
début
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Bonjour', nom) ;
ii+1;
fin ;
fin.

Exemple 2. Écrire un algorithme pour résoudre une suite de 10 équations de la

forme ax + b = 0, où a et b sont des nombres réels.

algorithme Equation ;
var
a, b, x : real ;
i : entier ;
début
i0;
tantque i < 10 faire
début
écrire('Quel est la valeur de a ? ') ;
lire(a) ;
écrire('Quel est la valeur de b ? ') ;
lire(b) ;
ii+1;
si (a  0) alors
début
x  -b/a ;
écrire('La solution est : ', x)
fin
sinon
si b = 0 alors
écrire('Équation indéterminée')

37
 sinon
écrire('Équation impossible') ;
fin ;
fin.

Exemple 3. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus grand de ces nombres.

L’approche consiste à traiter un nombre à la fois et garder trace de la plus grande

valeur déjà rencontrée. Chaque nouvelle valeur lue est comparée à la plus grande
valeur courante. Si elle est plus grande, elle devient le nouveau plus grand. Si elle
est inférieure à la plus grande valeur courante, on conserve la plus grande valeur
courante et on lit la valeur suivante. Au départ la plus grande valeur courante est
initialisée au premier nombre lu.

algorithme maxliste ;
var
nombre, max : réel ;
i : entier ;
début
i1;
écrire('Entrez un nombre : ') ;
lire(nombre) ;
max  nombre ;
tantque (i < 100) faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre > max) alors
max  nombre ;
fin ;
écrire('Le plus grand nombre est : ', max) ;
fin.

Exemple 4. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus petit de ces nombres.

algorithme minliste ;
var
nombre, min : réel ;
i : entier ;
début

38
 i1;
écrire('Entrez un nombre : ') ;
lire(nombre) ;
min  nombre ;
tantque (i < 100) faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre < min) alors
min  nombre ;
fin ;
écrire('Le plus petit nombre est : ', min) ;
fin.

Exemple 5. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus petit et le plus grand de ces nombres.

algorithme maxminliste ;
var
nombre, min, max : réel ;
i : entier ;
début
i1;
écrire('Entrez un nombre : ') ;
lire(nombre) ;
min  nombre ;
max  nombre ;
tantque (i < 100) faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre < min) alors
min  nombre ;
si (nombre > max) alors
max  nombre ;
fin ;
écrire('Le plus petit nombre est : ', min) ;
écrire('Le plus grand nombre est : ', max) ;
fin.

39
Exemple 6. Écrire un algorithme pour lire une suite de 100 nombres et déterminer
le plus petit de ces nombres ainsi que sa position dans la liste. On envisagera le cas
de la première occurrence et le cas de la dernière occurrence.

algorithme posminliste ;
var
nombre, min : réel ;
i, indice : entier ;
début
i1;
écrire('Entrez un nombre : ') ;
lire(nombre) ;
indice  1 ;
min  nombre ;
tantque (i < 100) faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
ii+1;
si (nombre < min) alors
début
min  nombre ;
indice  i ;
fin ;
fin ;
écrire('Le plus petit nombre est : ', min) ;
écrire('Sa position dans la liste est : ', indice) ;
fin.

Exemple 7. Écrire un algorithme pour traiter une liste de 10 étudiants. Pour chaque
étudiant l’algorithme lit le nom de l’étudiant, sa note de contrôle continu et sa note
de synthèse dans une certaine unité de valeur, calcule la moyenne de l’étudiant et
affiche le message «… a pour moyenne :…). La note de contrôle continu compte
pour 30% et la note de synthèse pour 70%.

algorithme gestionote ;
var
nom : chaîne ;
note1, note2, moyenne : real ;
n: entier ;
début
n0;
tantque (n < 10) faire

40
 début
écrire('Quel est votre nom ? ') ;
lire(nom) ;
écrire('Votre note de contrôle continu ? ') ;
lire(note1) ;
écrire('Votre note de synthèse ? ') ;
lire(note2) ;
moyenne  0.3*note1 + 0.7*note2 ;
nn+1;
écrire(nom, 'a pour moyenne : ', moyenne);
fin ;
fin.

Exemple 8. Écrire un algorithme pour calculer les salaires hebdomadaires de n

employés temporaires. Pour chaque employé, le programme demande le nom, le
taux horaire et le nombre d’heures de travail effectuées, puis calcule le salaire de
l’employé. Les règles suivantes sont utilisées pour calculer le salaire d’un employé.
Les 40 premières heures sont considérées comme des heures régulières e payées au
taux normal. Les heures effectuées au delà des 40 premières heures sont
considérées comme des heures complémentaires et payées une fois et demie le taux
horaire.

algorithme Paie ;
var
nom : chaîne ;
Rate, HoursWorked : réel;
Salary, Regular, Overtime : réel ;
i, n: entier ;
début
écrire('Nombre employés :') ;
lire(n)
i0;
tantque (i < n) faire
début
écrire('Nom employé :') ;
lire(nom) ;
écrire('Taux horaire :') ;
lire(Rate) ;
écrire('Heures effectuées :') ;
lire(HoursWorked) ;
ii+1;
si (HoursWorked > 40) alors
Overtime  HoursWorked – 40.0

41
 sinon
Overtime  0 ;
Regular  HoursWorked – Overtime ;
Salary  Rate* Regular + 1.5*Rate*Overtime ;
écrire('Nom :', Nom) ;
écrire('Salaire : ', Salary);
fin ;
fin.

4.3 Les boucles contrôlées par un compteur

Dans certains cas où nous devons utiliser une instruction répéter…jusquà,

faire…tantque ou tantque…faire, le langage algorithmique nous offre une autre
possibilité qui simplifie davantage la construction des boucles. Nous pouvons le
faire lorsque nous connaissons d’avance combien de fois la boucle doit être
exécutée. Considérons la boucle tantque…faire suivante utilisée pour imprimer
les 10 premiers entiers positifs :

nombre  1 ;
tantque nombre  10 faire
début
écrire(nombre) ;
nombre  nombre + 1 ;
fin ;

La valeur de la variable nombre est utilisée pour contrôler la boucle. D’abord,

nombre est initialisé à sa valeur initiale (ici 1). La valeur courante de nombre est
ensuite comparée à sa valeur finale (ici 10). Si elle est inférieure ou égale à 10 le
corps de la boucle est exécuté puis la valeur de nombre est incrémentée de 1 et le
processus, à l’exception de l’initialisation est répété. Une seule instruction
algorithmique permet de combiner certaines de ces étapes ; il s’agit de l’instruction
pour…haut…faire dont la forme générale est :

pour compteur  valeurinitiale haut valeurfinale faire

instruction ;

En utilisant l’instruction pour…haut…faire, nous pouvons réécrire la boucle

tantque…faire ci-dessus de la manière suivante :

pour nombre  1 haut 10 faire

42
 écrire(nombre) ;

Cette boucle pour…haut…faire répète l’exécution de l’instruction écrire(nombre)

au fur et à mesure que la valeur de la variable nombre varie de 1 à 10. La valeur
initiale et la valeur finale peuvent être des expressions. Par exemple, si j est égal à
2 et k égal à 23 alors la boucle

pour nombre  j + 3 haut j * k - 4 faire

écrire(nombre) ;

est équivalente à :

pour nombre  5 haut 42 faire

écrire(nombre) ;

L’instruction pour…haut…faire permet uniquement la répétition d’une seule

instruction à la suite du mot réservé faire. Si nous voulons répéter plusieurs
instructions, nous devons utiliser une instruction composée :

pour compteur  valeurinitiale haut valeurfinale faire

début
instruction1 ;
instruction2 ;
...
instructionn ;
fin ;

L’instruction pour…haut…faire s’exécute de la manière suivante :

1. La variable de contrôle (compteur) est initialisée à sa valeur initiale.

2. La valeur courante de la variable de contrôle est comparée à sa valeur finale.
Si elle est inférieure ou égale à la valeur finale, le corps de la boucle est
exécuté.
3. La variable de contrôle est automatiquement incrémentée de 1.
4. Les étapes 2 et 3 sont répétées jusqu’à ce que la valeur de la variable de
contrôle devienne supérieure à la valeur finale.

La boucle pour…haut…faire est utile dans les problèmes où on connaît d’avance

les valeurs initiale et finale de la variable de contrôle. Ceci est généralement le cas
lorsqu’on travaille avec les vecteurs, un sujet que nous aborderons ultérieurement.

L’organigramme correspondant de la boucle pour…haut…faire est présenté dans

la figure ci-dessous :

43
Figure 3.4. Organigramme de la structure pour…haut…faire

i  valeurinitale

faux
i  i +1 i  valeurfinale

vrai

Corps de la boucle
B
oîte
termi
nal
Considérons l’exemple additionnel suivant. Il s’agit de calculer et d’imprimer le
produit des dix premiers entiers naturels non nuls.

produit  1 ;
pour i  1 haut 10 faire
produit  produit * i ;
écrire(produit) ;
B
oîte
Comparer ce code à celui que l’on obtiendrait
de en utilisant la boucle répéter …
jusquà, faire … tantque ou tantque … faire.
calcul

Considérons maintenant le problème suivant : on veut imprimer les entiers de 1 à

100 dans l’ordre inverse. Pour faire cela on peut utiliser la forme suivante de la
boucle pour :

pour nombre  100 bas 1 faire

écrire(nombre) ;

La boucle pour…bas…faire permet de spécifier la répétition d’une instruction en

faisant décrémenter la valeur de la variable de contrôle. Dans ce cas la boucle est
exécutée si la valeur initiale est supérieure ou égale à la valeur finale. Nous aurions
pu utiliser la boucle pour …bas…faire pour calculer le produit des 10 premiers
entiers naturels non nuls comme illustré dans un exemple précédent :

produit  1 ;
pour i  10 bas 1 faire
produit  produit * i ;

44
 écrire(produit) ;

La forme générale de l’instruction pour…bas…faire est la suivante :

pour compteur  valeurinitiale bas valeurfinale faire

instruction ;

où instruction est une instruction simple ou composée. Dans ce dernier cas,

l’instruction pour prend la forme

pour compteur  valeurinitiale bas valeurfinale faire

début
instruction1 ;
instruction2 ;
…
instructionn ;
fin ;

L’instruction pour…bas…faire s’exécute de la manière suivante :

1. La variable de contrôle (compteur) est initialisée à sa valeur initiale.

2. La valeur courante de la variable de contrôle est comparée à sa valeur finale.
Si la valeur courante de la variable de contrôle est inférieure ou égale à la
valeur finale, le corps de la boucle est exécuté.
3. La variable de contrôle est automatiquement décrémentée de 1.
4. Les étapes 2 et 3 sont répétées jusqu’à ce que la valeur de la variable de
contrôle devienne inférieure à la valeur finale.

L’organigramme correspondant à la boucle pour…bas…faire est présenté dans la

figure 3.5 ci-dessous.

La variable de contrôle, la valeur initiale et la valeur finale doivent être de type

entier. Nous allons assouplir cette condition plus tard, mais le point important est
qu’elles ne peuvent pas être de type réel. La valeur initiale de la variable de la
variable de contrôle est affectée une seule fois. Elle change au fur et à mesure que
la boucle est répétée. Cependant, lorsque la boucle se termine, la variable de
contrôle est indéfinie. Ceci signifie que l’on ne peut pas supposer que la variable
de contrôle a une valeur égale à la valeurfinale + 1 (ou égale à la valeurinitiale –
1). On traitera la variable de contrôle à la fin de la boucle pour comme une
variable indéfinie (non initialisée).

Figure 3.5. Organigramme de la structure pour…bas…faire.

45
 i  valeurinitale

faux
i  i -1 i  valeurfinale

vrai

Corps de la boucle
B
oîte
termi
nal
On peut utiliser l’instruction pour…haut…faire pour la lecture des données à
condition que celles-ci soient correctement arrangées. Pour utiliser la boucle
pour…haut…faire, on doit connaître exactement d’avance combien de valeurs on
va lire. Ceci peut être accompli en comptant d’abord les valeurs à lire et en
incluant le compte comme la première valeur à lire.

Comme exemple, considérons le problème qui consiste à calculer la moyenne de n

B
nombres ; le nombre n constituant la première donnée à lire.
oîte
de
algorithme CalculMoyenne ; calcul
var
nombre, total, moyenne : réel ;
i, n : entier ;
début
total  0 ;
écrire('Quelle est la valeur de n ?')
lire(n) ;
for i 1 haut n faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
total  total + nombre ;
fin ;
moyenne  total/n ;
écrire('La moyenne est : ', moyenne) ;
fin.

4.4 Utilisation de boucles pour la lecture des données

46
Considérons le problème suivant : écrire un algorithme pour calculer la moyenne
d’un ensemble quelconque de nombres. Ce qui différencie ce problème de celui
que nous avons traité précédemment est que nous ne connaissons plus d’avance
combien de nombres nous allons traiter. Dans le problème précédent nous savions
que nous devions traiter exactement 10 nombres. Nous étions par conséquent
capable de compter les nombres au fur et à mesure de leur lecture et terminer la
boucle dès que le compteur indique que toutes les valeurs attendues ont déjà été
lues. Dans la présente situation où nous ne connaissons pas a priori le nombre de
nombres que nous allons traiter, il se pose la question de savoir comment devra-t-
on procéder pour déterminer que toutes les valeurs ont déjà été lues et qu’il est
temps de terminer la boucle pour passer au calcul de la moyenne ?

Une première approche naïve consiste à compter manuellement les nombres et

utiliser le compte final comme dans le cas précédent. Cette approche trop simpliste
est non seulement encombrante mais inappropriée dans la plupart des cas. Une
approche plus élégante pour résoudre ce problème consiste à utiliser une sentinelle
pour indiquer la fin des données. Les données du problème sont préparées comme
d’habitude mais une valeur spéciale, qui ne peut pas être confondue avec les vraies
données est ajoutée à la fin de la liste. Cette valeur, que l’on appelle la sentinelle
est là pour indiquer la fin des données. Par exemple, si on suppose que les nombres
dont on veut calculer la moyenne doivent tous être positifs, alors on peut utiliser la
valeur –1 comme sentinelle.

Les données d’entrée de l’algorithme se présenterons alors de la forme suivante :

valeur valeur …. valeur -1

Toutes les valeurs à l’exception de –1 sont des données réelles et doivent être
utilisées dans le calcul de la moyenne. Le –1 est la sentinelle et ne devra pas être
utilisé dans le calcul de la moyenne. Une liste composée uniquement de la valeur –
1 sera considérée comme une liste vide.

Pour donc écrire un algorithme pour calculer la moyenne d’une liste de nombres
positifs se terminant –1, nous allons utiliser la valeur lue pour contrôler la boucle.
En d’autres termes, nous allons continuer à lire et à traiter les valeurs jusqu’à ce
l’on lise la valeur de la sentinelle. L’algorithme de calcul de la moyenne devient
alors :

algorithme CalculMoyenne ;
var

47
 nombre, total, moyenne : réel ;
nb : entier ;
début
(*Initialisation de compteur et total*)
nb  0 ;
total  0 ;
écrire('Entrez un nombre (-1 pour terminer) ') ;
lire(nombre) ;
tantque (nombre  -1) faire
début
total  total + nombre ;
nb  nb +1 ;
écrire('Entrez un nombre (-1 pour terminer) ') ;
lire(nombre) ;
fin ;

(*Calculer et écrire la moyenne}

si (nb > 0) alors
début
moyenne  total/nb ;
écrire('La moyenne est : ', Moyenne) ;
fin
sinon
écrire('La liste est vide. ') ;
fin.

Autres exemples

Exemple 1. Écrire un algorithme pour lire les noms et les années de naissance des
enfants d’une personne et imprimer à chaque fois le message, « … est âgé de …
ans ». La répétition prend fin quand on entre un nom égal à ‘*’.

algorithme agesenfants ;
var
nom : chaîne ;
naissance, age, année : entier ;
début
écrire('Quelle année de référence ? ') ;
lire(année) ;
écrire('Entrez un nom (* pour terminer) ') ;
lire(nom) ;
tantque nom  '*' faire
début

48
 écrire('Quelle est son année de naissance ? ') ;
lire(naissance) ;
age  année – naissance ;
écrire(nom, 'est âgé de', age, 'ans') ;
écrire('Entrez le prochain nom (* pour terminer) ') ;
lire(nom) ;
fin ;
fin.

Exemple 2. On peut imaginer que l’utilisateur s’amuse à répéter indéfiniment la

boucle de l’algorithme ci-dessus en refusant de frapper un nom égal à ‘*’. Nous
allons donc forcer que la boucle prenne fin au bout de 10 itérations au maximum. Il
faut donc ajouter une deuxième condition de terminaison contrôlée par un
compteur.

algorithme enfants ;
var
nom : chaîne ;
i, naissance, âge, année : entier ;
début
écrire('Quelle année de référence ? ') ;
lire(année) ;
i0;
écrire('Entrez un nom (* pour terminer) ') ;
lire(nom) ;
tantque (nom  '*') et (i < 10) faire
début
écrire('Quelle est son année de naissance ? ') ;
lire(naissance) ;
âge  année – naissance ;
écrire(nom, 'est âgé de', âge, 'ans') ;
écrire('Entrez le prochain nom (* pour terminer) ') ;
lire(nom) ;
ii+1;
fin ;
fin.

49
Exercices d’apprentissage

Exercice 3.3
Lesquelles des assertions suivantes s’appliquent à la structure faire…tantque
seule ? A la structure tantque…faire seule ? Aux deux à la fois ?
(a) le corps de la boucle est exécuté au moins une fois.
(b) l’expression logique qui contrôle la boucle est évaluée avant l’entrée de la
boucle.
(c) doit utiliser la construction début…fin si plusieurs instructions doivent être
répétées.
(d) le corps de la boucle peut ne pas être exécuté du tout.
(e) a une condition de terminaison.
(f) a une condition de répétition.

Exercice 3.4
Écrire un algorithme qui lit le nom et le sexe d’une personne et affiche le message
« Bonjour, Monsieur … » si la personne est de sexe masculin. Si la personne est de
sexe féminin, le programme lui demande si elle est mariée ou non. Si la personne
est mariée, le programme affiche le message « Bonjour, madame … » sinon il
affiche le message « Bonjour, Mademoiselle … ».

Exercice 3.5
Écrire un algorithme qui va répéter le traitement ci-dessus pour un nombre
quelconque de personne. La répétition s’arrête lorsque l’utilisateur entre un nom
égal à ‘*’.

Exercice 3.6
Écrire un algorithme qui demande à l’utilisateur de donner son nom, son sexe, son
année de naissance et une année de référence puis affiche le message « Monsieur
… votre âge est de … ans » si la personne est de sexe masculin et le message
« Madame … votre âge est de … ans » si la personne est de sexe féminin.

Exercice 3.7
Écrire un algorithme qui va répéter le traitement ci-dessus pour un nombre
quelconque de personne. La répétition s’arrête lorsque l’utilisateur entre un nom
égal ‘*’.

Exercice 3.8
Écrire un algorithme qui va répéter le traitement ci-dessus pour n personnes au plus
(n lu). La répétition s’arrête lorsque l’utilisateur entre un nom égal à ‘*’ ou que le
nombre de personnes traitées devient supérieur à n.

Exercice 3.9

50
Écrire un algorithme qui lit une suite de nombres positifs se terminant par –1 et
détermine le plus grand de ces nombres.

Exercice 3.10
Écrire un algorithme qui lit une suite de nombres positifs se terminant par –1 et
détermine le plus grand de ces nombres ainsi que sa position dans la liste.

Exercice 3.11
Quelle sera la sortie du segment d’algorithme ci-dessous ?

pour i  1 haut 5 faire

début
pour j  1 haut i faire
écrire('1') ;
écrireln ;
fin ;

Exercice 3.12
Quelle sera la sortie du segment d’algorithme ci-dessous ?

pour i  1 haut 6 faire

début
pour j  1 haut 6 faire
si (i = j) ou (i + j = 7) alors
écrire('1')
sinon
écrire('0') ;
écrireln ;
fin ;

Exercice 3.13
Écrire un algorithme qui calcule la somme des carrés des n premiers entiers
naturels non nuls.

Exercice 3.14
Écrire un algorithme qui lit un entier positif et calcule le factoriel de ce entier.

Exercice 3.15
Le chercheur médiéval Leonardo (Fibonacci) da Pisa, a proposé la suite infinie
dans laquelle chaque terme est la somme des deux termes précédents. Le n ème
nombre de Fibonacci est défini récursivement de la manière suivante :

1. Si n est égal à 0 ou à 1 alors le nème nombre de Fibonacci est égal à n,

51
 2. Si n est supérieur ou égal à 2 alors le nème nombre de Fibonacci est égal à la
somme des deux nombres de Fibonnaci précédents.

Écrire un algorithme qui calcule et imprime les 100 premiers nombres de

Fibonacci.

Exercice 3.16
Écrire un algorithme qui calcule et imprime les rapports entre les 100 premières
paires de nombres de Fibonacci consécutifs.

Exercice 3.17
La série de Maclaurin de la fonction exp(x) est donnée par :


x x2 xn xn
exp( x )  1     
1! 2! n! n 0 n!

Clairement, lorsque n devient grand, la contribution de chaque terme additionnel

devient très petite. Écrire un algorithme qui calcule et imprime les valeurs de
exp(x) obtenues en utilisant un nombre croissant de termes dans la série de
Maclaurin de exp(x). L’itération s’arrête dès que le terme courant devient inférieur
à un certain epsilon.

Exercice 3.18
Lorsqu’un capital est déposé dans une banque qui paie les intérêts une fois par
mois, et lorsque le capital initial et les intérêts restent en dépôt, les intérêts sont dits
composés. La formule de calcul du capital en dépôt Pn , lorsque un capital P0 est
déposé initialement et lorsque les intérêts sont payés à un taux d’intérêt I pour n
mois est :
Pn P0*(1I)n

Écrire un algorithme qui calcule et imprime le capital en dépôt Pn lorsque le

capital initial P0 est placé au taux d’intérêt I à la fin de chacun des n premiers
mois.

52
3.4 Autres types de données scalaires

Jusqu’à ce moment nous n’avons considéré que les types de données entier, réel et
booléen. Nous introduisons maintenant les autres types scalaires du langage
algorithmique. Les types que nous allons étudier sont le type caractère, en abrégé
char, et les types définis par l’utilisateur. Ces deux types sont très utiles pour
écrire les boucles.

Le type caractère

Même si nous avons utilisé des variables booléennes pour contrôler le cours de
l’exécution d’un algorithme, nous avons jusque là travaillé principalement avec des
valeurs numériques. Nous avons utilisé des chaînes de caractères pour formater les
sorties dans les instructions d’écriture ; cependant, ces chaînes de sont des
constantes et nous ne pouvons pas changer leurs valeurs. Il est important dans
certaines situations d’avoir des variables qui prennent des valeurs caractères. De
nombreuses applications nécessitent la manipulations de données caractères. Par
exemple, un algorithme qui imprime les factures des clients doit être capable de
travailler non seulement avec des données numériques impliquant les charges et les
paiements, mais doit aussi traiter des données alphabétiques tels que le nom du
client, son adresse, et ainsi de suite.
Le langage algorithmique offre le type de données standard caractère. Les éléments
du caractère sont les caractères individuels qui sont représentables dans un code
donné tel que le code ASCII. Une constante caractère est une chaîne de caractère
entre apostrophes.

Pour déclarer une variable de type caractère, on utilise une instruction de la forme :

var
identificateur : char ;

Pour lire une variable de type caractère, on utilise une instruction de la forme :

lire(lettre)

si lettre est une variable de type caractère. Cette instruction un caractère et affecte
sa valeur à la variable lettre.

Examinons maintenant un algorithme qui lit des caractères. L’algorithme ci-

dessous lit une suite de caractères et compte le nombre de blancs contenus dans la
chaîne.

algorithme CompteBlancs ;

53
const
Blank = ' ' ;
var
nbre : entier ;
Ch: char ;
début
nbre  0 ;
lire(Ch) ;
tantque (Ch  '.') faire
début
si (Ch = Blank) alors
nbre  nbre + 1;
lire(Ch) ;
fin;
écrireln('Nombre de blancs :', nbre) ;
fin.

L’algorithme ci-dessous lit une suite caractère se terminant par un point et imprime
chaque mot sur une ligne séparer. On suppose que les mots sont séparés les uns des
autres par un seul caractère blanc.

algorithme Words;
const
Blank = ' ';
var
Ch : char;
début
lire(Ch);
tantque (Ch  '.') faire
début
si (Ch = Blank) alors
écrireln
sinon
écrire(Ch) ;
lire(Ch) ;
fin;
fin.

Exercices de contrôle connaissances

Question 1. Considérons l’algorithme suivant. Quel sera la sortie si l’entrée est :

« Ceci est une question sur les caractères, cependant, elle n’est pas difficile. »

54
algorithme Words;
var
Ch: char;
début
répéter
lire(Ch);
si (Ch  ',') alors
écrire(Ch)
sinon
écrireln;
jusquà (Ch = '.');
fin.

Question 2. Que fait l’algorithme suivant ?

algorithme Words;
const
Blank = ' ';
var
Ch: char;
début
lire(Ch);
tantque (Ch  Blank) faire
début
tantque (Ch  Blank) faire
début
écrire(Ch) ;
lire(Ch) ;
fin ;
lire(Ch) ;
fin;
fin.

Les types de données définis par l’utilisateur

Les types de données que nous étudiés jusque là (entier, réel, caractère, booléen)
sont tous des types standards. Le langage algorithmique donne aussi aux
programmeurs la possibilité de définir leurs propres types de données. Ceci est
souvent utile pour simplifier les structures de contrôle et donc améliorer la lisibilité
des algorithmes. Un programmeur peut définir un nouveau type scalaire de deux
manières :

55
 1. En énumérant toutes les valeurs qu’une variable de ce type peut prendre, ou
2. En restreignant l’intervalle des valeurs d’un type existant.

 Les types énumérés

Supposons que l’on ait besoin d’une boucle pour calculer le revenu
hebdomadaire d’un employé connaissant son revenu journalier pour les jours allant
de lundi à vendredi. Une solution peut prendre la forme suivante :

total  0 ;
pour day 1 haut 5 faire
début
lire(dailypay) ;
total  total + dailypay ;
fin;

On suppose bien entendu que des déclarations appropriées ont été effectuées
auparavant. Plus spécifiquement, on suppose que la variable day a été déclarée de
la manière suivante :

var
day : entier ;

Une meilleure approche consisterait à déclarer la variable day de la manière

suivante :

var
day : (dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi) ;

Ce que cette déclaration fait est d’énumérer toutes les valeurs possibles que la
variable day peut prendre. On peut maintenant réécrire la boucle comme suit :

total  0 ;
pour day  lundi haut vendredi faire
début
lire(dailypay) ;
total  total + dailypay ;
fin;

Le sens de la boucle est clairement plus apparent dans cette deuxième expression.
La variable day dans cette deuxième illustration est dite être de type défini par
l’utilisateur. On aurait pu rendre ce type plus explicite en utilisant une définition de
type pour avoir un type avec son propre identificateur :

56
 type
tweekday = (dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi) ;

var
Day : tweekday ;

La définition de type ci-dessus rend disponible un identificateur pour le nouveau

type scalaire tweekday. On peut ensuite utiliser ce nouveau type pour déclarer des
variables de ce type comme nous l’avons fait avec la variable Day.

La forme générale d’une définition de type scalaire énuméré est :

type
identificateur = (identificateur1, identificateur2, …, identificateurn) ;

On se rappellera que lorsqu’on utilise une définition de type, l’identificateur que

l’on choisit pour le type n’est pas un nom de variable et que l’on ne peut par
conséquent pas lui affecter des valeurs. Dans l’exemple ci-dessus, le rôle joué par
l’identificateur WeekDay est exactement le même que celui joué par les
identificateurs prédéfinis entier, réel, caractère ou booléen. En effet, le type
booléen est un type énuméré prédéfini. Sa définition est :

type
booléen = (faux, vrai) ;

Nous n’avons bien entendu pas besoin de spécifier cette définition dans nos
algorithmes, car elle est directement offerte par le langage algorithmique.

De même que l’identificateur de type n’est pas une variable, il en est de même des
identificateurs qui représentent les différentes valeurs possibles de ce type. Nous
ne pouvons pas affecter de valeur à lundi ou à mardi, de même que nous ne
pouvons pas affecter de valeur à vrai ou à faux. La définition d’un type scalaire
énuméré introduit non seulement un nouvel identificateur de type mais fait aussi la
chose suivante :

1. Enumère les identificateurs dénotant les constantes du nouveau du type ;

2. Définit l’ordre de ces constantes.

L’ordre dans lequel les valeurs sont listées dans la définition de type établit l’ordre
pour ce type. Dans l’exemple ci-dessus, dimanche a été listé le premier. Ceci rend
dimanche inférieur à toutes les autres valeurs de la liste. De même, lundi est
inférieur à toutes les autres valeurs qui le suivent. A cause de cet ordre, tout

57
identificateur qui est utilisé pour spécifier une valeur dans un type énuméré ne peut
apparaître que dans une seule définition de type à la fois. Les deux définitions de
type suivantes, prises ensemble, sont invalides :

type
tcouleur = (rouge, bleu, jaune) ;
tnuance = (rose, gris, jaune, rouge);

Si les deux définitions sont admises, on ne pourra pas décider si jaune < rouge ou
rouge < jaune.

Les types de données scalaires énumérés sont à usage interne uniquement. On peut
affecter et tester de telles valeurs dans un algorithme, mais on ne peut pas les lire
ou écrire en utilisant une instruction de lecture ou une instruction d’écriture. Il
existe cependant des astuces que nous pouvons utiliser pour lire ou écrire
indirectement de telles valeurs. Supposons par exemple que la variable sexe soit
déclarée de la manière suivante :

var
sexe : (Féminin, Masculin) ;

L’instruction ci-dessous peut être utilisée pour affecter une valeur à la variable
sexe.

lire(Ch) ;
si Ch = 'M' alors
sexe  Masculin
sinon
si Ch = 'F' alors
sexe  Féminin ;

De même, l’instruction ci-dessous peut être utilisée pour écrire la valeur de la

variable sexe

si sexe = Masculin alors

écrire('Masculin')
sinon
écrire('Féminin') ;

 Les types intervalles

58
 Il arrive souvent qu’une valeur soit destinée à recevoir des valeurs d’un certain
type dans un intervalle spécifique uniquement. Par exemple, on peut avoir la
déclaration suivante :

var
année : entier ;

Cependant dans l’algorithme, les valeurs de la variable année seront toujours

comprises entre 1900 et 2002. La déclaration

var
année : 1900..2020 ;

réalise cette restriction. Par ailleurs, le système génère un code pour vérifier
qu’aucune valeur en dehors de cet intervalle n’est affectée à année lorsque le
programme s’exécute. Si une telle affectation est tentée, elle résulte en une erreur
d’exécution et le programme s’arrête. Ce genre de vérification peut être utile
lorsque le programme est entrain d’être exécuté.

Tout comme dans le cas des types scalaires énumérés, on peut définir
explicitement un type intervalle en utilisant une instruction de définition de type.
La forme générale d’une définition de type intervalle est :

type
identificateur = valeurinf .. valeursup ;

Des exemples de définitions de type intervalle sont les suivants :

type
tettre = 'A'..'Z' ;
tpériode = 1900..2220 ;
tworkday = lundi..vendredi ;

La dernière définition de type est uniquement valide si le type énuméré WeekDay,

comme nous l’avons vu précédemment, a été défini avant la définition de
tworkday. Les types intervalles peuvent être définis pour les entiers, les caractères
et les types énumérés. Les types intervalles ne sont pas autorisés pour les réels.

Fonctions ayant des paramètres scalaires

Le langage algorithmique a des fonctions prédéfinies qui sont utiles quand on

travaille avec des types scalaires. Ces fonctions sont les suivantes :

59
 Tableau 3.1. Quelques fonctions prédéfinies sur les types ordinaux

Nom Description Type argument Type résultat

succ(x) Délivre le successeur de x Un type ordinal Idem
pred(x) Délivre le prédécesseur de x Un type ordinal Idem
ord(x) Délivre la valeur ordinale de x Un type ordinal Entier
chr(x) Délivre le caractère associé à x Entier Caractère

Les fonctions succ et pred sont utilisées avec n’importe lequel type scalaire, à
l’exception du type réel, pour obtenir le successeur ou le prédécesseur d’une valeur
donnée. Quand elles sont utilisées avec les entiers, les fonctions pred et succ
peuvent être employées pour incrémenter ou décrémenter les compteurs.
Le prédécesseur de la première valeur et le successeur de la dernière valeur dans
un type énuméré ne sont pas définis. L’ordre des valeurs dans un type énuméré est
défini par l’ordre dans lequel les constantes de ce type sont énumérées.
Chaque valeur dans un type énuméré est associée à un nombre qui indique sa
position dans la liste. La première valeur est associée à la position 0, la deuxième à
la position 1, et ainsi de suite. Les nombres qui indiquent la position des constantes
dans la liste sont appelés les nombres ordinaux des constantes correspondantes. La
fonction prédéfinie ord retourne le nombre ordinal de son argument.

60