Séquence 3

Les structures conditionnelles

Les algorithmes écrits dans les séquences précédentes correspondaient à des pro-
grammes ayant une structure séquentielle : les instructions s'exécutaient les unes
après les autres, dans l'ordre où elles étaient écrites.
Cependant, on a parfois besoin de ne faire un traitement que dans certaines
conditions.
C'est à cela que servent les structures de contrôle conditionnelles.
On a également besoin parfois d'exécuter plusieurs fois le même traitement sur
des données différentes, c'est à cela que servent les structures de données itéra-
tives, qui font l'objet de la séquence suivante.
Les structures conditionnelles servent à faire un traitement uniquement dans
certains cas, et si le cas n'est pas réalisé, à faire éventuellement d'autres traite-
ments.

Contenu

Les structures conditionnelles ......................................................... 93

Partie 1 .................................................................................................................. 94
La structure conditionnelle : Si…Alors…Sinon ................................... 94
1. Présentation de la structure ................................................................ 94
1A. Première forme .......................................................................................... 94
1B. Seconde forme .......................................................................................... 96
1C. Présentation des 2 formes en même temps ........................................... 98

Partie 2 ................................................................................................................ 100

Imbrication de Si…Alors…Sinon ............................................................ 100
Partie 3 ................................................................................................................ 104
Les choix multiples....................................................................................... 104
1. Syntaxe ................................................................................................... 104
2. Remarques importantes concernant cette structure .................... 104
2A. Le Sinon..................................................................................................... 104
2B. L'expression et les valeurs....................................................................... 104
2C. Les blocs d'instructions ........................................................................... 105
2D. Comparaison avec Si…Alors…Sinon…FinSi ........................................... 106
2E. Limites de cette structure ....................................................................... 108

93
8 3989 TG PA 01

83989TGPA0107-seq03 93 6/09/07 11:07:32

 Séquence 3

Partie 1
La structure conditionnelle : Si…Alors…Sinon

1. Présentation de la structure
On peut utiliser cette structure sous 2 formes.

1A. Première forme

Condition est une expression
Si condition booléenne, et la liste
d'instructions indiquées
Alors
dans la partie Alors ne sera
exécutée que si condition est
vraie.
//Liste d'instructions

Finsi

Si la condition condition est Si condition signifie en fait Si condition = vrai.

fausse, aucune des instructions
suivant le Alors ne sera
exécutée.
Simplement, on n'écrit pas Si condition = vrai car pour
tout booléen bool, écrire si bool signifie si bool = vrai.
Vous verrez que selon les booléens, ce n'est pas toujours
évident de garder à l'esprit qu'écrire si bool signifie si
bool = vrai.

94
8 3989 TG PA 01

83989TGPA0107-seq03 94 6/09/07 11:07:32

 Les structures conditionnelles

Exemples de conditions

Lexique Algo Remarque

a (entier, calculé) Si a < 4 et leMot <> "Charles" La liste d'instructions sera
leMot (chaîne, saisie) Alors exécutée si les 2 conditions sont
vraies en même temps.

// liste d'instructions
Finsi
a (entier, calculé) Si a < 4 et trouvé Ici, comme dans l'exemple
trouvé (booléen, calculé) Alors précédent, la liste d'instructions
sera exécutée si les 2 conditions
sont vraies. La 2e condition,
// liste d'instructions trouvé signifie : si trouvé = vrai.
Finsi
a (entier, calculé) Si a < 4 ou leMot <> "Charles" La liste d'instructions sera
leMot (chaîne, saisie) Alors exécutée si une des conditions
est vraie ou si les 2 conditions
sont vraies en même temps.
// liste d'instructions
Finsi

Exemple d'algo utilisant un "Si…Alors…Sinon…Finsi"

L'algo suivant affiche un message si le nombre saisi est un multiple de 3, sinon, il ne fait
rien. Un nombre est multiple de 3 si le reste de la division entière de ce nombre par trois
est égal à 0 :

Lexique Algo Multiple de 3

nombre (entier, saisi) : nombre à tester Début
Afficher ("Saisir un nombre")
Saisir (nombre)
Si nombre mod 3 = 0
Alors Afficher("Vous avez saisi le nombre ", nombre")
Afficher("Ce nombre est un multiple de 3")
FinSi
Fin

Vous avez remarqué que les instructions dépendant du Alors sont décalées par rapport
aux instructions ne figurant pas dans le Alors ?
Ce procédé de décalage s'appelle l'indentation et permet de faire en sorte que les algos
(et les programmes) soient plus lisibles : on voit mieux un Si…Alors…Finsi (ou d'autres
structures que l'on verra ultérieurement) quand on indente les instructions qu'il con-
tient.

95
8 3989 TG PA 01

83989TGPA0107-seq03 95 6/09/07 11:07:32

 Séquence 3

1B. Seconde forme

Si condition
Alors

//Liste d'instructions
Sinon
//Liste d'instructions
Si la condition condition
est vraie, alors ce sont les
instructions de la partie
Alors qui seront exécutées.
si la condition condition
est fausse, alors, ce sont
les instructions de la partie
Sinon qui seront exécutées.

Finsi

Le Sinon, ici, signifie si non condition,

c'est à dire qu'il signifie si non
condition = vraie, il signifie donc si
condition = fausse.

Exemples
Je reprends ci-après les exemples présentés au paragraphe précédent, et je vous propose
de regarder de près quelles sont les valeurs des conditions qui entraînent le fait que ce
soient les instructions contenues dans le sinon qui soient exécutées et non les instruc-
tions contenues dans le alors.

96
8 3989 TG PA 01

83989TGPA0107-seq03 96 6/09/07 11:07:32

 Les structures conditionnelles

Lexique Algo Remarque

a (entier, calculé) Si a < 4 et leMot <> "Charles"
leMot (chaîne, saisie) Alors
// liste d'instructions
Sinon
// Liste d'instructions
Finsi
a (entier, calculé) Si a < 4 et trouvé
trouvé (booléen, calculé) Alors
// liste d'instructions
Sinon
// Liste d'instructions
Finsi
a (entier, calculé) Si a < 4 ou leMot <> "Charles" Ici, les instructions du sinon
leMot (chaîne, saisie) Alors
// liste d'instructions
Sinon
Les instructions du sinon seront
exécutées et pas les instructions
du alors si la condition a < 4 et
LeMot <> "Charles" est fausse,
c'est-à-dire, si on reprend nos
règles sur les booléens, si non
(a<4 et leMot <> "Charles") est
vraie, c'est-à-dire finalement si a
>= 4 ou leMot = "Charles"
Ici, comme dans l'exemple
précédent, ce sont les instructions
du sinon qui seront exécutées si
l'expression booléenne a < 4 et
trouvé est fausse, c'est-à-dire si
a >= 4 ou trouvé = faux, c'est-à-
dire si a >= 4 ou si trouvé = faux
ou les 2.
seront exécutées si non (a < 4 ou
LeMot <> "Charles") est vrai, c'est-
à-dire si a>=4 et leMot = Charles.

// Liste d'instructions
Finsi

Exemple d'algo : On peut, en guise d'exemple, reprendre le même exercice qu'au para-
graphe 1A (test si un nombre est multiple de 3), mais le compléter en faisant en sorte que
si le nombre saisi n'est pas multiple de 3, alors un message l'indique à l'utilisateur.

Lexique Algo Multiple de 3

nombre (entier, saisi) : nombre à tester Début
Afficher ("Saisir un nombre")
Saisir (nombre)
Si nombre mod 3 = 0
Alors Afficher("Ce nombre est un multiple de 3")
Sinon Afficher("Ce nombre n'est pas multiple de 3")
FinSi
Fin

Le sinon signifie : si non (nombre mod 3 = 0) c'est-à-dire que cela signifie :

si nombre mod 3 <> 0.

97
8 3989 TG PA 01

83989TGPA0107-seq03 97 6/09/07 11:07:32

 Séquence 3

Remarque : On aurait très bien pu écrire l'algorithme précédent comme suit.

Lexique Algo Multiple de 3

nombre (entier, saisi) : nombre Début
à tester Afficher ("Saisir un nombre")
Saisir (nombre)
Si nombre mod 3 = 0
Alors Afficher("Ce nombre est un multiple de 3")
FinSi
Si nombre mod 3 <> 0
Alors Afficher ("Ce nombre n'est pas multiple de 3")
FinSi
Fin
C'est juste, mais pas optimisé car les deux conditions seront évaluées au lieu d'une seule
dans le cas de l'utilisation d'une structure si…alors…sinon.
Donc, dans la mesure où les conditions des 2 si sont complémentaires, il est plus judicieux
d'utiliser un si…alors…sinon.

1C. Présentation des 2 formes en même temps

La présentation des 2 formes possibles d'utilisation de la structure si…alors…sinon
revient en fait à dire que la partie sinon de la structure est optionnelle, ce qui, dans la
présentation de la syntaxe algorithmique et dans la présentation de la syntaxe des lan-
gages de programmation se note par des crochets [ ] :

Si condition
Alors

//Liste d'instructions Les crochets indiquent que

la partie sinon est optionnelle.
[Sinon

//Liste d'instructions]
Finsi

98
8 3989 TG PA 01

83989TGPA0107-seq03 98 6/09/07 11:07:33

 Les structures conditionnelles

Exercice 21
Écrire l'algorithme d'affichage du plus grand de 2 nombres saisis au clavier et répondez à la
question suivante : que se passe-t-il si les 2 nombres saisis sont identiques ?

Exercice 22
Écrire un algorithme qui simule le jeu de pile ou face.
Déroulement du jeu : l'utilisateur saisit la lettre P pour pile, et F pour face, puis valide sa saisie
(ou bien il clique sur le bouton « Pile » ou le bouton « Face » dans le cas d'une interface gra-
phique et événementielle).
Le programme, lui, choisit aléatoirement un nombre entre 0 et 1.
Si le nombre tiré au sort est 0, alors pile est gagnant, face est perdant.
Si le nombre tiré au sort est 1, alors pile est perdant et face est gagnant.
Le programme affiche un message : gagné ou perdu.

Remarque : pour écrire cet algo, vous avez besoin d'une fonction que vous ne con-
naissez pas encore, appelons cette fonction hasard. La fonction hasard retourne un
nombre, choisi aléatoirement, et compris entre les 2 nombres passés en paramètres.
Exemples :
hasard (2,15), retourne un nombre choisi aléatoirement entre 2 et 15.
L'instruction monChoix ← hasard (2,15) a pour effet de ranger dans la variable mon-
Choix un nombre choisi aléatoirement entre 2 et 15.

Exercice 23
Écrire l'algorithme qui calcule et affiche le maximum de 3 nombres saisis au clavier par l'utili-
sateur.
Attention, il n'est pas question de « sortir l'artillerie lourde » en cherchant quel est le plus
grand nombre, quel est le 2e plus grand et quel est le plus petit.
Tout ce qu'on veut, c'est le plus grand.
Il n'est donc pas nécessaire de comparer ces 3 nombres 2 à 2, ce qui ferait 4 comparaisons.
Deux comparaisons suffisent pour obtenir ce qu'on veut.

Passons maintenant à la seconde partie de cette séquence. Elle traite des conditionnelles
imbriquées les unes dans les autres.

99
8 3989 TG PA 01

83989TGPA0107-seq03 99 6/09/07 11:07:33

 Séquence 3

Partie 2
Imbrication de Si…Alors…Sinon

Lorsqu'une condition ne suffit pas pour départager tous les cas possibles, on peut
« emboîter » des structures conditionnelles les unes dans les autres.
Forme générale :

Si condition1
Alors
Si condition2
Alors // On arrive ici si condition1 et condition2 sont vraies

// Liste d'instructions

[Sinon // On arrive ici si condition1 est vraie et si condition2 est fausse

// C'est-à-dire si condition1 et non condition2

// Liste d'instructions]

FinSi
[Sinon // Si condition1 = faux

// On peut remettre ici encore un Si…Alors…Sinon

// Liste d'instructions]

FinSi

Exemple : On reprend le jeu de pile ou face et on l'écrit avec des si…alors…sinon imbri-
qués.

Lexique Algo pile ou face

choixUtil (caractère, saisi) : caractère choisi Début
par l'utilisateur. Afficher ("Taper P pour pile, F pour face")
hasard (fonction, résultat : entier) : Saisir (choixUtil)
retourne un nombre choisi aléatoirement choixOrdi ← hasard (0,1)
entre les 2 entiers passés en paramètres. Si choixOrdi = 0
choixOrdi (entier, calculé) : résultat d'appel Alors si choixUtil = "P"
de la fonction hasard.
Alors message ← "Gagné"
message (chaîne, calculé) : message
Sinon message ← "Perdu"
indiquant à l'utilisateur s'il a gagné ou
perdu sa partie de pile ou face. Finsi
Sinon si choixUtil = "P"
Alors message ← "Perdu"
Sinon message ← "Gagné"
Finsi
Finsi
Afficher (message)
Fin

100
8 3989 TG PA 01

83989TGPA0107-seq03 100 6/09/07 11:07:33

 Les structures conditionnelles

Exercice 24
Même exercice que l'exercice 21, en prévoyant l'affichage d'un message lorsque les nombres
saisis sont égaux.

Exercice 25
Calcul du salaire d'un employé.
L'utilisateur saisit le nombre d'heures travaillées, le salaire horaire et l'ancienneté de l'employé.
Les retenues de sécurité sociale sont calculées à partir du salaire brut multiplié par le taux de
retenue de la sécurité sociale qui est une constante valant 0.19.
L'employé bénéficie d'une prime d'ancienneté qui équivaut à 2% du salaire brut pour + de 10
ans et -20 ans d'ancienneté et 5% du salaire brut pour + 20 ans d'ancienneté.

Exercice 26
Écrire l'algorithme du jeu suivant : ce jeu se joue à 2 joueurs.
Le premier joueur saisit un mot de 4 lettres à l'abri du regard du deuxième joueur.
Puis, le deuxième joueur doit deviner quel est ce mot et le saisir.
Il a droit à 3 essais.
À chaque essai, le programme lui indique s'il a trouvé le mot ou bien, le cas échéant, quelles
sont les bonnes lettres aux bonnes places parmi celles qu'il a saisies.
Exemple : si le mot à trouver est cape et que le joueur a saisi rate, le programme lui affiche :
- a – e.
Si, au bout de 3 essais, le joueur n'a pas trouvé le mot, un message lui indique quel était le mot
à trouver.

Exercice 27
Écrire l'algo qui permet d'afficher dans l'ordre alphabétique 4 mots saisis dans un ordre quel-
conque.
Une réflexion s'impose avant de se jeter tête baissée dans l'écriture de cet algo.
Réfléchissons bien.
Pour 4 mots saisis, il peut y avoir 24 solutions d'ordre différentes. En effet, on peut avoir :
• Mot1, mot2, mot3, mot4,
• Ou bien mot1, mot2, mot4, mot3,
• Ou bien mot1, mot3, mot2, mot4,
• Ou bien mot1, mot3, mot4, mot2,
• Ou bien mot1, mot4, mot2, mot3,
• Ou bien mot1, mot4, mot3, mot2.
Cela fait déjà 6 solutions, rien que dans le cas où mot1 est le premier mot dans l'ordre alpha-
bétique. On a encore 6 solutions si la liste triée commence par mot2, 6 solutions si elle com-
mence par mot3 et 6 solutions si elle commence par mot4, ce qui nous fait bien 24 solutions
possibles.
Donc, il n'est pas très judicieux de vouloir écrire un algo qui teste toutes ces solutions. Pour s'en
persuader, il suffit de lire ci-dessous le début de cet algo.
Le principe de cet algo est simple : On compare les mots saisis entre eux et en fonction du
résultat de la comparaison, on les range dans 4 variables m1, m2, m3 et m4 que l'on affiche
à la fin de l'algo.

101
8 3989 TG PA 01

83989TGPA0107-seq03 101 6/09/07 11:07:33

 Séquence 3

Lexique Algo Tri de 4 mots saisis – Solution pas futée

mot1, mot2, mot3, mot4 Début
(chaînes, saisies) : mots Saisir (mot1, mot2, mot3, mot4)
à trier et à afficher dans
l'ordre lexicographique. Si mot1 < mot2
Alors Si mot2 < mot3
m1, m2, m3, m4 (chaînes, Alors Simot3 < mot4
calculées) : liste des 4 mots Alors m1 ! mot1
triés.
m2 ! mot2
m3 ! mot3
m4 ! mot4
Sinon // c'est-à-dire si mot3 >= mot4
m1 ! mot1
m2 ! mot2
m3 ! mot4
m4 ! mot3
FinSi
// On a réglé le cas de 2 solutions
// sur les 24.
Sinon // mot1 < mot2 et mot2 >= mot3
Si mot1 < mot3 // mot1 < mot3 < mot2
Alors Si mot4 < mot1 // mot4 < mot1 < mot3 < mot2
Alors m1 ! mot4
m2 ! mot1
m3 ! mot3
m4 ! mot2
Sinon // mot4 >= mot1
Si mot4 < mot 3
// mot1 < mot4 < mot3 < mot2
Alors m1 ! mot1
m2 ! mot4
m3 ! mot3
m4 ! mot2
// etc…etc…
// A ce stade d'avancement de l'algo, on n'a réglé le cas que de 4 solutions
// sur les 24 possibles.
// Vous imaginez la taille finale de l'algo ? Pour trier 4 mots ?
// Il faut trouver une solution plus futée que celle-ci …
Fin

102
8 3989 TG PA 01

83989TGPA0107-seq03 102 6/09/07 11:07:34

 Les structures conditionnelles

Allez, je vous mets un peu sur la piste… Pour ceux qui en ont besoin bien sûr.
Relativement à vos connaissances actuelles, pour vous en sortir, vous avez au moins les 2 solu-
tions suivantes.
• Commencer par trier les 2 premiers mots saisis, puis insérer le 3e mot saisi au bon endroit
(soit en premier dans la liste, soit en 2e dans la liste, soit en dernier dans la liste), puis cela
une fois fait, insérer le 4e mot saisi au bon endroit (en premier, en deuxième, en 3e ou en
dernier).
Cette méthode de tri s'appelle le tri par insertion et nous la reprendrons plus loin, pour
trier un nombre important d'objets, lorsque nous aurons abordé les traitements répétitifs
(on dit : itératifs).
• Encore plus futé : comparer les mots 2 à 2 et intervertir leurs places si le 2e mot est inférieur
au premier mot. Cette méthode de tri s'appelle le tri à bulle car au fur et à mesure du tri,
les objets les plus petits remontent en haut de la liste comme des bulles d'air qui remon-
tent à la surface de l'eau (oh ! C'est beau hein ce que je dis !)

Bon, eh ben bon courage ! Et ne foncez pas tout de suite sur les solutions du corrigé !
Ci-après, nous abordons une autre structure conditionnelle.

103
8 3989 TG PA 01

83989TGPA0107-seq03 103 6/09/07 11:07:34

 Séquence 3

Partie 3
Les choix multiples

Cette structure est à utiliser lorsqu'on est en présence de nombreux cas simples.
Cela évite d'avoir recours à de trop nombreux Si…Alors…Sinon…FinSi.

1. Syntaxe
SelonCas expression faire
valeur1 : // Liste d'instructions exécutée si expression =
// valeur1
valeur2 : // Liste d'instructions exécutée si expression =
// valeur2
...
valeurN : // Liste d'instructions exécutée si expression =
// valeurN
[ Sinon : // Liste d'instructions, exécutée si l'expression n'a aucune
// des valeurs allant de valeur1 à valeurN ]
FinSelon

2. Remarques importantes concernant cette structure

2A. Le Sinon
Si expression n'est égale à aucune des valeurs allant de valeur1 à valeurN, c'est le bloc
Sinon qui est exécuté. Comme vous avez pu le remarquer, ce bloc est optionnel puisque
je l'ai encadré par des crochets.

2B. L'expression et les valeurs

Expression et valeur1, valeur2,…., valeurN doivent être du même type.
Expression peut être soit un nombre ou une expression arithmétique, soit un booléen
ou une expression booléenne, soit une chaîne de caractères ou une expression mani-
pulant des chaînes de caractères.
Plusieurs valeurs de l'expression peuvent entraîner un même traitement.

104
8 3989 TG PA 01

83989TGPA0107-seq03 104 6/09/07 11:07:34

 Les structures conditionnelles

Exemple

Algo Exemple d'un même traitement pour plusieurs valeurs

Lexique
de l'expression.
nombre (entier, saisi) Début
Afficher ("Saisir un nombre entre 0 et 9")
Saisir (nombre)
SelonCas nombre faire
1,3,5,7,9 : Afficher ("Nombre impair")
0,2,4,6,8 : Afficher ("Nombre pair")
FinSelon
Fin

K Valeur1,…, valeurN peuvent être des intervalles de valeurs.

Exemple

Lexique Algo exemple de selon cas avec intervalles de valeurs

nombre (entier, saisi) Début
Saisir (nombre)
SelonCas nombre faire
3: Afficher ("Ce nombre vaut 3")
2..4 : Afficher ("Ce nombre est compris
entre 2 et 4")
Sinon : Afficher ("Ce nombre ne vaut pas 3 et n'est
pas compris entre 2 et 4")
FinSelon
Fin

La ligne 2..4 : Afficher ("Ce nombre est compris entre 2 et 4") signifie que si la variable
nombre appartient à l'intervalle 2..4 (c'est-à-dire si nombre est compris entre 2 et 4),
alors les traitements de ce bloc seront exécutés.

2C. Les blocs d'instructions

Les listes d'instructions figurant dans chaque cas peuvent comporter n'importe quelles
instructions, y compris des instructions SelonCas, des Si…Alors…Sinon et toutes les ins-
tructions que l'on va découvrir plus loin dans le cours.

105
8 3989 TG PA 01

83989TGPA0107-seq03 105 6/09/07 11:07:34

 Séquence 3

Exemple

Début
//Imaginez qu'ici, on lit dans un fichier de produit les renseignements concernant un
// produit particulier, ces renseignements étant TypeProduit et RefProduit
SelonCas TypeProduit faire
"1" : Afficher ("C'est un produit alimentaire")
"2" : Afficher ("C'est un produit de nettoyage")
Sinon : SelonCas RefProduit faire
"AAA" : Afficher ("Produit AAA")
"BBB" : Afficher ("Produit BBB")
"CCC" : Si Prix < 100
Alors Afficher ("Promotion")
FinSi
FinSelon
FinSelon
Fin

2D. Comparaison avec Si…Alors…Sinon…FinSi

Si on traduit la structure SelonCas (celle présentée dans le paragraphe 1 – Syntaxe) avec
des Si…Alors…Sinon…FinSi, ça donne :

Si expression = valeur1
Alors // Liste d'instructions exécutées si expression = valeur1
Sinon Si expression = valeur2
Alors // Liste d'instructions exécutées si expression = valeur2
Sinon Si ……….
Sinon Si expression = valeurN
Alors // Liste d'instructions exécutées si expression =
// valeurN
Sinon // Liste d'instructions, exécutées si l'expression n'a
// aucune des valeurs allant de valeur1 à valeurN
FinSi
FinSi
FinSi
FinSi
Fin

Cette comparaison a pour but de vous montrer que quand on est entré dans un des cas,
tous les autres cas sont sautés, et l'exécution reprend après le mot clé FinSelon.
Cela signifie que même si la valeur d'une expression correspond à plusieurs cas, le pro-
gramme exécute la première liste d'instructions correspondant au cas de l'expression,
puis sort de la structure FinSelon.
106
8 3989 TG PA 01

83989TGPA0107-seq03 106 6/09/07 11:07:35

 Les structures conditionnelles

Exemple

Lexique Algo exemple de selon cas

nombre (entier, saisi) Début
Saisir (nombre)
SelonCas nombre faire
3: Afficher ("Ce nombre vaut 3")
2..4 : Afficher ("Ce nombre est compris entre 2 et 4")
Sinon : Afficher ("Ce nombre ne vaut pas 3 et n'est
pas compris entre 2 et 4")
FinSelon
Fin

Dans cet algo, si le nombre saisi vaut 3, alors le message Ce nombre vaut 3 s'affiche,
sinon (c'est-à-dire si nombre <> 3), si le nombre est compris entre 2 et 4, le message Ce
nombre est compris entre 2 et 4 s'affiche, sinon (c'est-à-dire si nombre <> 3 et si nombre
n'est pas compris entre 2 et 4), alors, c'est le message Ce nombre ne vaut pas 3 et n'est
pas compris entre 2 et 4 qui s'affiche.
Si le nombre vaut 3, bien que 3 soit compris entre 2 et 4, le programme quitte la struc-
ture SelonCas après avoir trouvé et exécuté les instructions correspondant à la première
valeur satisfaisante.
Donc, si l'utilisateur saisit 3, le résultat d'exécution de ce programme sera l'affichage du
message : "Ce nombre vaut 3".
Maintenant, je modifie l'algo comme suit :

Lexique Algo exemple de selon cas

nombre (entier, saisi) Début
Saisir (nombre)
SelonCas nombre faire
2..4 : Afficher ("Ce nombre est compris entre 2 et 4")
3: Afficher ("Ce nombre vaut 3")
Sinon : Afficher ("Ce nombre ne vaut pas 3
et n'est pas compris entre 2 et 4")
FinSelon
Fin

Dans ce cas, si l'utilisateur saisit 3, le résultat d'exécution sera l'affichage du message Ce

nombre est compris entre 2 et 4.

O IlSelonCas
existe des langages de programmation dans lesquels les cas d'une structure
ne sont pas exclusifs, comme par exemple le langage javascript, auquel je
vous initie dans le support de programmation web. Dans ce support, nous faisons
les tests nécessaires à la compréhension de cette structure SelonCas.

107
8 3989 TG PA 01

83989TGPA0107-seq03 107 6/09/07 11:07:35

 Séquence 3

2E. Limites de cette structure

Vous pouvez constater que les conditions de lancement des traitements sont plus limi-
tées avec cette structure :
• on ne peut pas écrire de condition composée pour lancer tel ou tel bloc d'instruc-
tions ;
• les conditions concernent l'égalité de l'expression avec des valeurs ou au mieux des
fourchettes de valeurs (en cas d'utilisation d'un intervalle).
Pour simuler des conditions composées, on peut toujours imbriquer des structures
SelonCas les unes dans les autres, ou bien utiliser des Si…Alors…Sinon dans les blocs
d'instructions du SelonCas.
Nous allons rôder tout ça avec quelques exercices.

108
8 3989 TG PA 01

83989TGPA0107-seq03 108 6/09/07 11:07:35

 Les structures conditionnelles

Exercice 28
Écrire un algorithme qui propose un menu affiché à l'écran, et qui, en fonction du choix fait
par l'utilisateur, effectue soit la somme, soit le produit, soit la moyenne de 2 nombres saisis.
Prévoir le cas où l'utilisateur a fait une erreur de saisie.

Exercice 29
L'utilisateur saisit la date au format jj/mm/aaaa, et le programme affiche la date avec le mois
en lettres.
Exemple : si l'utilisateur saisit 15/10/2007, alors le programme affiche : Aujourd'hui, on est le
15 octobre 2001.
Attention !! Si le mois saisi est erroné, un message s'affiche, indiquant à l'utilisateur qu'il a
fait une erreur de saisie.

Exercice 30
Écrire l'algorithme qui affiche la conjugaison d'un verbe du premier groupe saisi par l'utilisa-
teur à la personne choisie.
Au lancement, un message invite l'utilisateur à saisir le verbe qu'il souhaite conjuguer.
Deux messages s'affichent ensuite, lui permettant de choisir d'une part le pronom de conjugai-
son, d'autre part le nombre (singulier ou pluriel) souhaités.
Si l'utilisateur saisit arriver puis choisit 2e personne et singulier, le message Tu arrives s'affiche.

Remarques :
• Il n'est pas nécessaire, dans cet algo de prévoir d'éventuelles erreurs de saisie pour
la personne et le nombre, car lors de la traduction, nous utiliserons des cases à
options, ce qui empêche l'utilisateur de faire d'autres choix que ceux proposés.
• Pour pouvoir conjuguer un verbe, il faut, à partir de son infinitif, récupérer sa
racine, qui est la partie commune de toutes les formes conjuguées du verbe.
Exemple : pour le verbe danser, la racine est dans. Autrement dit, il faut enlever les deux
derniers caractères du verbe saisi, quelle que soit la longueur de ce verbe.
Pour ce faire, on a besoin d'utiliser la fonction SousChaîne, à laquelle on passe en para-
mètre une expression arithmétique utilisant la fonction longueur. À vos cerveaux ! Je ne
vous en dirai pas plus.

Voilà, on se retrouve pour le TP.

109
8 3989 TG PA 01

83989TGPA0107-seq03 109 6/09/07 11:07:35

83989TGPA0107-seq03 110 6/09/07 11:07:35