Algorithmique Instructions de base et Variables

Algorithmique
Conditions et Itérations
Cours de BTS/CPI 1ère année
Algo – Prog CPI/BTS1 – M. Dravet – 17/09/2003
Dernière modification: 17/09/2003
Instructions Conditionnelles
• Dans les chapitres précédents, tous les algos que nous
avons vu se lisent séquentiellement.
• Ce cas de figure nous limite énormément en possibilités
de raisonnements algorithmiques,
• En effet, nous raisonnons sans cesse par prises de
décisions, en fonction de choix qui s’imposent à nous
constamment.
• Il est donc logique qu’en Algorithmique nous disposions
du même outils: L’instruction conditionnelle.
Instructions Conditionnelles
• L’instruction conditionnelle a pour but de représenter une
suite d’actions résultant d’une décision préalable, fondée
sur l’évaluation d’une condition précise.
• Selon les cas, un bloc d’instruction sera exécuté plutôt
qu’un autre.
• La syntaxe de cette instruction est:
Si condition
Alors liste d'instructions
Sinon liste d'instructions
Fin si
Instructions Conditionnelles
• Cette instruction est composée de trois parties
distinctes:
– La condition introduite par Si
– La clause Alors
– La clause Sinon
• La condition est une expression dont la valeur est de
type booléen. Elle est évaluée.
• Si elle est vraie, les instructions de la clause Alors sont
exécutées
• Dans le cas contraire, les instructions de la clause Sinon
sont exécutées.
Instructions Conditionnelles
• On peut utiliser une forme simplifiée de la conditionnelle,
sans clause sinon.
• La syntaxe est alors :
si condition
alors liste d'instructions
fin si
Instructions Conditionnelles
• Il est tout à fait possible d’utiliser plusieurs instructions
dans la clause Si ou Sinon.
• Ces multiples instructions forment alors un « bloc » de
code.
• En algo, chaque bloc de code doit être délimité par des
balises « Début » et « Fin ».
Instructions Conditionnelles
• On écrira donc:
Si condition Alors
Début
instruction 1
instruction 2
Fin
Sinon Début
instruction 3
instruction 4
Fin
Fin si
Instructions Conditionnelles
• Exercice :
Ecrire un algorithme qui demande deux nombres
entiers à l’utilisateur, et qui affiche le plus grand
des deux.
Exemple:
Veuillez saisir un nombre: 45
Veuillez saisir un autre nombre: 34
Le plus grand des deux est: 45
Instructions Conditionnelles
Programme PlusGrand
Déclarations
Variables x,y
:
entier { valeurs lues au clavier }
Début
écrire(‘Veuillez saisir un nombre: ’)
lire(x)
écrire(‘Veuillez saisir un autre nombre: ’)
lire(y)
écrire(‘Le plus grand des deux est: ‘)
Si x>y alors écrire(x)
sinon écrire(y)
Fin si
Fin
Instructions Conditionnelles
• Une instruction conditionnelle Si—Alors—Sinon—Finsi
étant avant tout une instruction comme une autre, il est
aussi possible de l’utiliser dans un bloc d’instruction déjà
utilisé dans un bloc si—alors—sinon—finsi
• On dit alors qu’on imbrique les structures
conditionnelles.
• Le nombre d’imbrications est illimité.
Instructions Conditionnelles
• On écrira donc:
Si condition Alors
Si condition2 Alors
Début
bloc d’instruction
Fin
Sinon Début
bloc d’instruction
Fin
Fin Si
Sinon
Si condition3 alors instruction
Sinon instruction
Fin si
Instructions Conditionnelles
• Exercice :
Ecrire un algorithme qui demande deux nombres
entiers à l’utilisateur, et qui affiche le plus grand
des deux si x <> y
Exemple:
Veuillez saisir un nombre: 45
Veuillez saisir un autre nombre: 34
Le plus grand des deux est: 45
Instructions Conditionnelles
Programme PlusGrand
Déclarations
Variables x,y
:
entier { valeurs lues au clavier }
Début
écrire(‘Veuillez saisir deux nombres: ’)
lire(x, y)
Si x<>y Alors
Si x>y alors écrire(‘Le plus grand des deux est: ‘, x)
sinon écrire(‘Le plus grand des deux est: ‘, y)
Fin Si
Sinon écrire(‘Les deux nombres sont égaux !’)
Fin si
Fin
Instructions conditionnelles
• Il existe un autre type d’instruction conditionnelle, un peu
moins utilisé.
• Il permet d’éviter la redondance des si—alors—sinon
• On dit que c’est davantage une structure de « choix »
que conditionnelle :
• Si—alors—sinon fait exécuter des actions en fonction
d’une condition précise
• « Selon sélecteur faire » lance des traitements
dépendant de la valeur du sélecteur.
Instructions conditionnelles
• Notation dans un algo:
Selon sélecteur Faire
Ensemble1 de valeurs : Traitement1
Ensemble2 de valeurs : Traitement2
…
Ensemble n-1 de valeurs : Traitement n-1
Sinon Traitement n
Fin Selon
Instructions conditionnelles
• Exemple:
Ecrire un algorithme qui demande à l’utilisateur de saisir un
chiffre.
L’algorithme a pour simple tâche d’écrire la valeur de ce
chiffre en toutes lettres à l’utilisateur. L’algorithme ne
connaîtra que les chiffres allant de 0 à 5, pour les autres
il avouera à l’utilisateur son ignorance.
Ecrire deux formes de cet algorithme:
– En version « instruction conditionnelle »,
– En version « sélecteur de choix ».
Instructions conditionnelles
• Version structure conditionnelle
Programme EcrireChiffre
Déclarations
Variable ch
:
entier
{ chiffre de l’utilisateur saisi au clavier }
Début
lire(ch)
Si ch = 0 alors écrire(‘Zéro’)
Sinon Si ch = 1 alors écrire(‘Un’)
Sinon Si ch = 2 alors écrire(‘Deux’)
Sinon Si ch = 3 alors écrire(‘Trois)
Sinon Si ch = 4 alors écrire(‘Quatre’)
Sinon Si ch = 5 alors écrire(‘Cinq’)
Sinon écrire(‘je ne sais pas !’)
FinSi
FinSi
FinSi
FinSi
FinSi
FinSi
Fin
Instructions conditionnelles
• Version structure conditionnelle
Programme EcrireChiffre
Déclarations
Variable ch :
entier { chiffre de l’utilisateur saisi au clavier }
Début
lire(ch)
Selon ch faire
0 : écrire(‘Zéro’)
1 : écrire(‘Un’)
2 : écrire(‘Deux’)
3 : écrire(‘Trois’)
4 : écrire(‘Quatre’)
5 : écrire(‘Cinq’)
Sinon écrire(‘Je ne sais pas !’)
Fin Selon
Fin
Exercices
• Ecrire un algorithme qui permet d’écrire le résultat d'un
étudiant à un module sachant que ce module est
sanctionné par une note d'oral de coefficient 1 et une
note d'écrit de coefficient 2.
• La moyenne obtenue doit être supérieure ou égale à 10
pour valider le module.
• Exemple:
Veuillez entrer la note à l’écrit: 13
Veuillez entrer la note à l’oral: 11
Résultat: Admis.
Exercices
Programme Admission
Déclarations
Variable note_ecrit : réel
note_oral : réel
moyenne : réel
Début
lire(ne)
lire(no)
moyenne  (2*ne + no) / 3
Si moyenne < 10
Alors écrire(‘Refusé’)
Sinon écrire(‘Admis’)
Fin si
Fin
{ note à l’écrit coeff 2 }
{ note à l’oral coeff 1}
{ moyenne de l’élève }
Exercices
• On veut écrire un algorithme permettant de calculer le
salaire d'un employé payé à l'heure, à partir de son
salaire horaire et du nombre d'heures de travail.
• Les règles de calcul sont les suivantes : le taux horaire
est majoré pour les heures supplémentaires de :
– 25% au-delà de 160 heures
– 50% au-delà de 200 heures.
• On demande à l’utilisateur le salaire horaire de l’employé
ainsi que le nombre d’heure travaillées
Exercices
Programme Salaire
Déclarations
Variable sh
: réel
{ salaire horaire }
nbh
: réel
{ nombre d’heures travaillées }
salaire
: réel
{ salaire à verser à l’employé }
Début
lire(sal_horaire)
lire(nb_heures)
Si nbh < 160 alors salaire  nbh * sh
Sinon si nbh < 200
alors salaire  160*sh + (nbh - 160)*1,25*sh
sinon salaire  160*sh + 40*sh*1,25 + (nbh - 200)*sh*1,5
Fin si
Fin si
écrire(‘Salaire à verser: ‘, salaire)
Fin