ENS BTA Département Info TIC 4

CHAPITRE 3 : STRUCTURES DE CONTROLES

1- Le schéma conditionnel

Syntaxe :
Si < condition > alors
Action 1 ;
Sinon
Action 2 ;
Fin si ;

Il peut arriver que l’on souhaite exécuter une instruction sous certaines conditions, l’algorithme
ressemblera à quelque chose comme : « Si la condition est vérifiée alors exécuter les
instructions appropriées pour ce cas. Si par contre, la condition n’est pas vérifiée, alors
exécuter un autre ensemble d’instructions ».

Le schéma conditionnel permet donc de mettre une condition à l’exécution d’une

action.

Dans la syntaxe ci-dessus, < condition >est une expression booléenne, si elle est vraie, l’action
1 est exécutée, si elle est fausse, l’action 2 est exécutée.

Il peut arriver que l’on ne s’intéresse pas à l’un des cas, alors l’une des actions sera vide et le
schéma conditionnel prendra la forme suivante :
Si < condition > alors
Action ;
Fin si ;

Exemple 1 : Ecrivons un algorithme qui récupère la note d’un étudiant et affiche « succès » si
elle est au moins égale à 10 et « échec » dans le cas contraire.
Algorithme Résultat ;
Var note : Réel ;
Début
Afficher (‘’ Entrer la note de l’étudiant ‘’) ;
Lire (note) ;
Si note >= 10 alors
Afficher (‘’ succès ‘’) ;
Sinon
Afficher (‘’ échec ‘’) ;
Finsi ;
Fin

Il peut arriver que l’une des actions, soit un autre schéma conditionnel. On arrive dans ce cas
à des schémas conditionnels imbriqués (les uns dans les autres).

1
ENS BTA Département Info TIC 4

Exemple 2 : Reprenons l’exemple précédent en considérant qu’un étudiant qui obtient une
note supérieure à 8 mais inférieur à 10 est repêché. Essayons d’écrire un nouvel algorithme
tenant compte de ces nouveaux éléments.

Algorithme Délibération ;
Var note : Réel ;
Const Moyenne =10 ;
Début
Afficher (‘’ Entrer la note de l’étudiant ‘’) ;
Lire (note) ;
Si note >= Moyenne alors
Afficher (‘’ succès ‘’) ;
Sinon
Si note < 8 alors Si (note > 8) Et (note < 10) alors
Afficher (‘’ échec ‘’) ; Afficher (‘’ Repêché ‘’) ;
Sinon Sinon
Afficher (‘’ Repêché ‘’) ; Afficher (‘’ échec ‘’) ;
Finsi ; Finsi
Finsi ;
Fin

 STRUCTURE DE CAS :

Il peut arriver que pour une variable (V) pouvant prendre les valeurs V1, V2, V3, … Vn on veuille
y exécuter des instructions différentes en fonction de la valeur prise par V. On obtiendra alors
un schéma conditionnel imbriqué suivant :

Si V = V1 alors
Action 1 ;
Sinon
Si V = V2 alors
Action 2 ;
Sinon …
Si V = Vn alors
Action n ;
Sinon
Action ;
Finsi ;
Finsi ;
Finsi ;

Ce schéma peut alors être remplacé par une structure de cas encore appelé schéma
conditionnel généralisé qui est le suivant :

2
ENS BTA Département Info TIC 4

Cas V vaut
V1 : Action 1 ;
V2 : Action 2 ;

Vn : Action n ;
Autrement Action ;
Fin Cas

Exemple 3 : Ecrivons un algorithme qui récupère un nombre compris entre 1 et 7 et affiche le

jour de la semaine correspondant.
Algorithme JourDeLaSsemaine ;
Var nombre : entier ;
Début :
Afficher (‘’ Entrer un nombre compris entre 1 et 7 ‘’) ;
Lire (nombre) ;
Cas nombre Vaut
1 : Afficher (‘’ Lundi ‘’) ;
2 : Afficher (‘’ Mardi ‘’) ;
3 : Afficher (‘’ Mercredi ‘’) ;

7 : Afficher (‘’ Dimanche ‘’) ;

Autrement afficher (‘’ Erreur ‘’) ;
Fincas ;
Fin.

2- Les Itérations

Encore appelé structures répétitive ou boucle, une itération correspond à toute répétition
d’une action ou d’une séquence d’action.

a-) Le schéma « Répéter »

Syntaxe : Répéter
< Action(s) > ;
Jusqu’à < condition > ;
Cette boucle permet de répéter l’exécution de l’action ou de la séquence d’action
jusqu’à ce que la condition soit vraie.

3
ENS BTA Département Info TIC 4

Exemple 4 : Ecrivons un algorithme qui affiche les 10 premiers entiers naturels.

Algorithme DixPremiersEntiers ;
Var i : entier ;
Début
i 0;
Répéter
Afficher (i);
i i+1
Jusqu’à (i > 9);
Fin.

Exemple 5 : Ecrivons un algorithme qui affiche la table de multiplication par 9.

Algorithme MultiplicationPar9
Var i : entier
Début
i 1;
Répéter
Afficher (‘’ 9X ‘’,i, ‘’=’’, 9 * i);
i i+1
Jusqu’à (i > 12);
Fin.

b-) Le schéma « Tant que »

Syntaxe : Tant que < condition > faire
Action (s) ;
FinTantque ;

Cette boucle permet d’exécuter une instruction ou une liste d‘instructions tant qu’une
certaine condition est vérifiée.
Exemple 6 : Ecrivons un algorithme qui affiche les 10 premiers entiers naturels.
Algorithme DixPremiersEntiers ;
Var i : entier ;
Début
i 0;
Tant que i < 10 faire
Afficher (i) ;
i i+1
Fintantque;
Fin.

4
ENS BTA Département Info TIC 4

Exemple 7 : Algorithme pour la Multiplication par 9

Algorithme MultiplicationPar9
Var i, p : entier
Début
i 1;
Tant que i < 13 faire
p 9*i
Afficher (‘’ 9X ‘’,i, ‘’=’’, p);
i i+1
Fintantque;
Fin.

Remarque (Sur la boucle Répéter ou Tant que)

La différence avec boucle Répéter est que dans cette dernière, on entre au moins
une fois car l’action est exécutée avant le texte sur la condition (on exécute là-bas l’action
avant de voir si la condition est vérifiée). Alors que dans le cas de la boucle tant que, si dès le
départ la condition n’est pas vérifiée, l’action n’est pas exécutée.
C-) Le schéma « Pour »
Syntaxe :
Pour V de Vi à Vf Pas inc Faire
Action(s) ;
Finpour ;
Avec :
V : Variable de contrôle
Vi : Valeur initiale de V
Vf : Valeur finale de V
Inc : Valeur de l’incrément (quantité à ajouter à la valeur actuelle de V à chaque itération).

En général, lorsque la valeur de l’incrément vaut 1, on ne le précise pas et le schéma pour

devient alors :
Pour V de Vi à Vf Faire
Action(s) ;
Finpour ;
Exemple 8 : Affichage des 10 premiers entiers naturels.
Algorithme DixPremiersEntiers ;
Var k : entier ;
Début
Pour k de 0 à 9 faire
Afficher (k) ;
Finpour;
Fin.

5
ENS BTA Département Info TIC 4

Exemple 9 : Affichage des 10 premiers entiers naturels par ordre décroissant.

Algorithme DixPremiersEntiersDec ;
Var j : entier ;
Début
Pour j de 9 à 0 Pas -1 faire
Afficher (j) ;
Finpour;
Fin.

Exemple 10 : Table de multiplication par 9

Algorithme TableDeMultiplicationpar9 ;
Var cmpt, nb : entier ;
Début
Afficher (‘’ Entrer un nombre ‘’) ;
Lire (nb) ;
Pour cmpt de 1 à 12 faire
Afficher (nb, ‘’x’’, cmpt,’’=’’, nb*cmpt) ;
Finpour ;
Fin.

NB : Le schéma « pour » est utilisé lorsqu’on connait à l’avance le nombre d’itération. De plus,
la variable de contrôle V varie automatiquement d’une valeur initiale à une valeur finale selon
le Pas.
Alors que dans les 2 boucles précédentes (« Répéter » et « Tant que »), c’était au
programmeur d’initialiser la variable de contrôle et de la faire varier par incrémentation. On
prendra toujours soin de ne pas modifier la variable de contrôle dans un schéma « pour ».
Exercice : Ecrire un algorithme qui demande à l’utilisateur d’entrer une liste de nom, jusqu’à
ce que ce dernier saisisse la chaîne de caractère ‘’ quitter ‘’.
Algorithme SuitesDeNoms ;
Var nom : chaîne ;
Début
Afficher (‘’ pour quitter saisissez « quitter »’’) ;
Afficher (‘’ Entrer un nom ‘’) ;
Lire (nom) ;
Tant que nom < > ’’quitter’’ faire
Afficher (‘’ Entrer un nom ’’) ;
Lire (nom) ;
Fintantque;
Fin.

Ou :

6
ENS BTA Département Info TIC 4

Algorithme ListDeNoms
Var N : chaîne ;
Réponse : caractère ;
Début
Répéter
Répéter
Afficher (‘ Entrer un nom ‘) ;
Lire (N) ;
Jusqu’à N = ‘’ Quitter ‘’ ;
Afficher (‘’ Etes-vous sur de vouloir quitter ? (O / N) ‘’) ;
Lire (Réponse)
Jusqu’à (Réponse O) ;
Fin.

REMARQUE:
Dans ces deux algorithmes utilisant les boucles « tant que » et « Répéter », on
ne connait pas à l’avance le nombre de nos que l’utilisateur saisira avant de quitter, on ne
connait pas le nombre d’itération, on ne pourrait donc pas utiliser la boucle « pour ».