Chapitre III : Les Schémas De Programme

Nous étudions dans ce chapitre les notions fondamentales liées à l’algorithmique telles que
les schémas conditionnels et les schémas itératifs.

Les instructions sont habituellement regroupées dans des structures algorithmiques

particulières, appelées structures de contrôle, permettant de décrire avec précision la suite des
opérations à effectuer pour réaliser un certain traitement. Les principales structures de contrôle du
langage algorithmique sont :

 La structure séquentielle (schéma séquentiel) qui permet de spécifier un ensemble

d’instructions devant être exécutées les unes à la suite des autres.

Exemple : Algorithme qui lit deux nombres réels a et b (a non nul), puis calcule la solution de
l’équation Ax + B = 0.

Algorithme équation
var
A,B, x : réel ;
Début
écrire (‘entrez la valeur de A’) ;
lire(A) ;
écrire (‘entrez la valeur de B’) ;
lire(B) ;

écrire(x =  , -B/A) ;
fin
 La structure de sélection (schéma conditionnel) qui permet de choisir entre deux ou
plusieurs instructions celle qui doit être exécutée en fonction de la valeur d’une certaine
condition. On distingue la structure de sélection simple (les Si) et la structure de
sélection multiple (les cas).

1
 I. Structure de sélection Si

On distingue trois formes possibles :

a. Première forme : Si alors

Si (condition) Alors

Instructions

Finsi

Dans cette forme, arrivé à la première ligne (Si Alors) la machine examine la valeur de
condition. Si cette condition a pour valeur VRAI, elle exécute la série d’instructions. En revanche,
dans le cas où le booléen est faux, l'ordinateur saute directement aux instructions situées après le
FinSi. La condition ici est une expression logique.

Exemple :

Var

x , y : entier ;

x=20 ; y=18 ;

Si(xy) alors

Ecrire(’x est plus grand que y’) ;

finSi

b. Deuxième forme : Si alors Sinon

Si (condition) Alors

Instructions 1

Sinon

Instructions 2

Finsi

2
 Dans le cas où condition est VRAI, et après avoir exécuté la série d'instructions 1, au
moment où elle arrive au mot « Sinon», la machine saute directement à la première instruction
située après le « Finsi ». De même, au cas où condition a comme valeur « Faux », la machine saute
directement à la première ligne située après le « Sinon » et exécute l’ensemble des « instructions
2 ». Dans tous les cas, les instructions situées juste après le FinSi seront exécutées normalement.

Exemple : algorithme qui saisit une valeur entière et affiche son double si cette donnée est
inférieure à un seuil donné.

Algorithme SimpleOuDouble

Constante

SEUIL = 10 ;

Var

val : entier ;

début

ecrire(‘entrez un entier : ‘) ;

lire (val) ;

si (val < SEUIL)alors

Ecrire (‘Voici son double :’, val ×2) ;

sinon

Ecrire (‘Voici la valeur inchangée :’, val) ;

fsi

fin

c. Troisième forme : Sinon Si (Tests imbriqués)

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.

3
 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é.

Exemple 1 : Considérons le problème qui consiste à lire deux nombres entiers et imprime
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 comparexy
var
x, y : entier ;
début
écrire(‘entrez les valeurs de x et y’) ;
lire (x, 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
Exemple 2 : Écrire un algorithme pour résoudre le système d’équations linéaires d’inconnues x

et y :

Ax + By = C
Dx + Ey = F

algorithme systemexy
var
A,B, C, D, F, F, detxy, detx, dety : réel ;
début
lire(A, B, C, D, E, F) ;

4
 detxy  A*E – D*B ;
detx  C*E – F*B ;
dety  A*F – D*C;
si (detxy  0) alors
écrire(x =  , detx/detxy, y = , dety/detxy)
sinon
si (detx = 0) et (dety = 0) alors
écrire(Le système admet une infinité de solutions)
sinon
écrire(Le système est impossible);
fin

II. Structure de sélection multiple : les cas

Cette structure permet de choisir un bloc d’instructions à exécuter parmi plusieurs.

Synthaxe :
Cas (expression) vaut
Valeur1 : instructions1
Valeur2 : instructions2
---------------------
---------------------
Valeurn : instructionsn
finCas
Exemple 1 :
Var
Jour : entier ;
Cas(jour) vaut
Cas 1 :
Ecrire(‘Lundi’) ;
Cas 2 :
Ecrire(‘Mardi’) ;
--------------------------
-------------------------

5
 Cas 7 :
Ecrire(‘Dimanche’) ;
finCas
Exemple 2 :
Var
Jour : entier ;
Cas (jour) vaut
Cas 6 :
Ecrire(‘Samedi’) ;
Cas 7 :
Ecrire(‘Dimanche’) ;
Autre valeur
Ecrire (‘j’attends avec impatience le weekend’) ;
finCas
III. Conditions composées

Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas être
exprimées sous la forme simple exposée ci-dessus. Si nous considérons l’expression « Toto est
inclus entre 5 et 8 ». En fait cette phrase cache non une, mais deux conditions. Car elle revient à
dire que « Toto est supérieur à 5 et Toto est inférieur à 8 ». Il y a donc bien là deux conditions,
reliées par ce qu’on appelle un opérateur logique, le mot ET.

Or l’informatique met à notre disposition quatre opérateurs logiques : ET, OU, NON, et XOR.

Le ET a le même sens en informatique que dans le langage courant. Pour que "Condition1
ET Condition2" soit VRAI, il faut impérativement que Condition1 soit VRAI et que Condition2
soit VRAI. Dans tous les autres cas, "Condition 1 et Condition2" sera faux.

Il faut se méfier un peu plus du Ou. Pour que "Condition1 OU Condition2" soit VRAI, il
suffit que Condition1 soit VRAIE ou que Condition2 soit VRAIE. Le point important est que si
Condition1 est VRAIE et que Condition2 est VRAIE aussi, Condition1 OU Condition2 reste
VRAIE.

6
Exemple : É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
Le XOR (ou OU exclusif) fonctionne de la manière suivante. Pour que "Condition1 XOR
Condition2" soit VRAI, il faut que soit Condition1 soit VRAI, soit que Condition2 soit VRAI.

Si toutes les deux sont fausses, ou que toutes les deux sont VRAI, alors le résultat global
est considéré comme FAUX.

Enfin, le NON inverse une condition : NON (Condition1) est VRAI si Condition1 est
FAUX, et il sera FAUX si Condition1 est VRAI.

IV. La structure de répétition (schéma itératif)

Une boucle ou itération est une instruction ou une séquence d’instructions décrite telle que
son exécution puisse répétée une ou plusieurs fois.

Les algorithmes que nous avons écrits jusque-là traitent 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

7
 Cet algorithme ne peut imprimer le message de bonjour personnalisé que pour une seule
personne au cours d’une exécution donnée. Si nous voulons imprimer ce même message pour
plusieurs personnes, nous devrons reprendre l’exécution de l’algorithme autant de fois que
nécessaires. Il sera cependant plus commode de faire en sorte qu’une fois l’exécution de
l’algorithme entamée, l’exécution des trois instructions :

écrire(Quel est votre nom ? ) ;

lire(nom) ;
écrire(Bonjour, nom)
Puissent être répétée autant de fois que nécessaires avant que l’algorithme ne se termine.
On a donc besoin d’une structure permettant de faire en sorte qu’une instruction ou un groupe
d’instructions soit exécuté plusieurs fois (de façon répétitive) dans un algorithme. Une telle
structure constitue ce que l’on appelle une boucle.

L’informatique met à notre disposition trois structures de répétition :

 La structure de répétition tantque -- -- -- -- - faire

Syntaxe :

tantque (condition) faire

Instructions
ftantque
La boucle tant que répète plusieurs fois le bloc de code(instructions) tant que la condition spécifiée
est vraie.
L’instruction tantque … faire s’exécute de la manière suivante :
1. On évalue la condition de répétition de la boucle.

2. Si elle a la valeur vraie, on exécute le corps de la boucle et on recommence à l’étape 1. Si

elle a la valeur fausse, on quitte la boucle et l’exécution continue avec l’instruction qui suit
la boucle tantque …faire.

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 répétition (modificateur de boucle) pour garantir que
celle-ci deviendra fausse après un nombre fini d’étapes.

8
Exemple 1 : Affichage des nombres de 0 à 4

Var
i :entier ;
i=0 ;
tantque(i < 5) faire
ecrire(i) ;
i++ ;
ftantque

i dans cet exemple est appelé le modificateur de boucle. C’est la variable qui fait évoluer la boucle
et qui permet de sortir de la boucle quand elle prend la valeur 5.

Exemple 2 :

Var

Nombre : entier ;

Ecrire (‘entrez un nombre’) ;

Lire(nombre) ;

Tantque (nombre < > -1) faire

Ecrire (‘le nombre est :’, nombre) ;

Ecrire (‘entrez un nombre’) ;

Lire(nombre) ;

Fintanque

Ecrire (‘fin du programme’) ;

 La structure de répétition repeter - - - - jusqu’à

La boucle répéter - - - - jusqu’à est une variante de la boucle tant que. Cette boucle va
exécuter le bloc de code une fois avant de vérifier si la condition est vraie ; puis elle va répéter la
boucle tant que la condition est fausse.

Syntaxe :

répéter

9
 instructions
jusquà (condition) ;

Exemple :
Var
i : entier ;
repeter
ecrire(i) ;
i++ ;
Jusqu’à (i< 5) ;

 La structure de répétition pour - - - - faire

On utilise cette boucle lorsqu’on connait combien de fois on veut répéter un bloc de code.
Les itérations étant comptées par une variable de contrôle.

Syntaxe :

Pour (compteur  valeur initiale à valeur finale) faire

Liste instructions

Fpour

L’instruction pour……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.

Exemple 1 :
Pour (i  0 à 5) faire

10
 Ecrire(i) ;
Fpour
Exemple 2 : Affiche les nombres impairs entre 1 et 10 (utilisation de pour avec pas).
Exemple 3 : Affiche les nombres de 10 à 1.
Pour (i 10 à 1) faire
Ecrire(i) ;
Fpour
Exemple 4 : considérons le problème qui consiste à calculer la moyenne de n nombres ; le nombre
n constituant la première donnée à lire.

algorithme CalculMoyenne
var
nombre, total, moyenne : réel ;
i, n : entier ;
début
total  0 ;
écrire('Quelle est la valeur de n ?')
lire(n) ;
pour i 1 à n faire
début
écrire('Entrez un nombre : ') ;
lire(nombre) ;
total  total + nombre ;
fin ;
fpour
moyenne  total/n ;
écrire('La moyenne est : ', moyenne) ;
fin

11