Vous êtes sur la page 1sur 43

Instructions conditionnelles

Organigramme:

Variable

Valeur_1 Valeur_2 Valeur_N Sinon

Instru_1 Instru_2 ……………. Instru_N Instru_PD

1
Instructions conditionnelles

- L’instruction par défaut n’est pas obligatoire. Si la variable n’est égale à


aucune des valeurs testées, dans ce cas, on ignore l’instruction Cas et on
passe automatiquement à l’instruction suivante.

Algorithme salut;
Var
Heure: entier;
Début
Exemple 1: Lire (Heure);
Cas Heure
6, 7, 8, 9, 10, 11, 12: Ecrire (« Bonjour »);
13.. 18: Ecrire (« Bon après-midi »);
Sinon Ecrire (« Bonsoir »);
Fincas
Fin
2
Algorithme Affiche_jour;
Var
jour: entier;
Début
Ecrire (Entrer le chiffre jour:’);
Lire (jour);
Cas jour
1: Ecrire (‘Lundi’);
Exemple 2: 2: Ecrire (‘Mardi’);
3: Ecrire (‘Mercredi’);
4: Ecrire (‘Jeudi’);
5: Ecrire (‘Vendredi’);
6: Ecrire (‘Samedi’);
7: Ecrire (‘Dimanche’);
Sinon
Ecrire (‘Ce n’est pas un jour de la semaine);
Fincas
Fin
3
Instructions conditionnelles

Exercice: Ordre de deux nombres

- Ecrire un algorithme permettant de saisir deux nombres entiers, X et Y,


et les afficher à l’écran dans l’ordre croissant.
Objets d’entrée:
- Premier nombre: X
- Deuxième nombre : Y

Objets de sortie:
- Les deux nombres X et Y dans l’ordre croissant.
4
Instructions conditionnelles

Algorithme:
 Algorithme Ordre_nombres;
Var
X, Y: entier;
Début
Ecrire (Entrer le premier nombre:’);
Lire (X);
Ecrire (Entrer le deuxième nombre:’);
Lire (Y);
Si Alors
Ecrire (‘Les deux nombres dans l’ordre sont:’, X, ‘puis:’, Y);
Sinon
Ecrire (‘Les deux nombres dans l’ordre sont:’, Y, ‘puis:’, X);
Finsi
Fin
5
Instructions conditionnelles

Exercice: Année bissextile

- Ecrire un algorithme qui permet de tester si une année est bissextile ou


non. Une année est bissextile si elle est divisible par 4 et pas par 100 ou
si elle est divisible par 400.

- L’équation traduisant une année bissextile est la suivante:

B= (D4 ET Non(D100)) OU D400

6
 Algorithme Année_bissextile;
Var
A, N: entier;
Début
Ecrire (Entrer l’année à tester:’);
Lire (A);
Si Alors
Si A Mod 100= 0 alors
Si A Mod 400= 0 alors
Solution: Ecrire (‘l’année est bissextile’);
Sinon
Ecrire (‘l’année n’est pas bissextile’);
FinSi
Sinon
Ecrire (‘l’année est bissextile’);
FinSi
Sinon
Ecrire (‘l’année n’est pas bissextile);
FinSi
Fin 7
Instructions conditionnelles

Exercice: Equation du deuxième degré


  - Ecrire un algorithme permettant de résoudre une équation du deuxième
degré:

- Objets d’entrée:
Premier coefficient: a,
Deuxième coefficient: b,
Troisième coefficient: c.
- Objets de sortie:
Les solutions: x1 ou (x1, x2) ou (z1, z2) 8
Instructions conditionnelles

Algorithme equation;   Ecrire (‘l’ensemble de solutions


Var est IR’);
a, b, c, d, X1, X2: Réels; Sinon
Début Ecrire (‘Equation impossible’);
Ecrire (‘Résolution d’une équation de FinSi
2eme degré:’); Sinon
Ecrire (‘Entrer le premier coefficient:’); X1 -c/b;
Lire (a); Ecrire (‘la solution est:’, X1);
Ecrire (‘Entrez le deuxième FinSi
coefficient:’); Sinon
Lire (b); d b*b - 4*a*c;
Ecrire (‘Entrez le troisième coefficient:’); Si d=0 Alors
Lire (c); X1 -b/(2*a);
Si a=0 Alors Ecrire (‘La solution est: ‘, X1);
Si b=0 Alors Sinon
Si c=0 Alors 9
Instructions conditionnelles

  Si d0 Alors
X1 (-b+ sqrt(d))/(2*a);
X2 (-b- sqrt(d))/(2*a);
Ecrire (‘les solutions réelles sont
x1=‘, x1, ‘et x2=‘, x2);
Sinon
X1 (-b)/(2*a);
X2 (sqrt(-d))/(2*a);
Ecrire (‘les solutions complexes sont
Z1=‘, x1 ,’ + i.’, x2,’ et Z2=‘ ,x1,’ + i.’ ,x2);
FinSi
FinSi
FinSi
Fin

10
Instructions conditionnelles

Exercice: Equation du deuxième degré

- Ecrire un algorithme permettant d’effectuer les remises suivantes suivant


le type d’abonné:
Ancien abonné: -15%
Etudiant : -20%
Nouvel abonné : -0%
Etranger : + 25%
- Objets d’entrée:
Tarif normal: TN
type de l’abonné: Q
11
Instructions conditionnelles

Exercice: Equation du deuxième degré

- Objets de sortie:
Prix à payer: PAP

- Objets intermédiaires:
Taux de remise: TR,
La remise: R.
- Formules:
TR= f(Q),
R= TN * TR
PAP= TN+ R 12
Instructions conditionnelles

Algorithme Revue;   cas Q


Var 1: TR -0.15;
Q: entier; 2: TR -0.2;
TN, TR, R, PAP: Réels; 3: TR 0;
Début 4: TR +0.25;
Ecrire (‘Calcul du prix d’abonnement à Fincas
une revue’); Si (Q1) ou (Q4) alors
Ecrire (‘Entrer le tarif normal:’); Ecrire (‘Erreur de choix’);
Lire (TN); Sinon
Ecrire (‘----------MENU----------’); R TN * TR;
Ecrire (‘Ancien abonnée-------1); PAP TN + R;
Ecrire (‘Etudiant------------------2); Ecrire (‘Le prix à payer est: ‘, PAP);
Ecrire (‘Nouvel abonnée-------3); Finsi
Ecrire (‘Etranger------------------4); Fin
Ecrire (‘Entrer la type de l’abonnée’);
Lire (Q); 13
Instructions conditionnelles

Exercice: Calcul sur les nombres réels

- Selon un choix effectué à partir d’un menu affiché à l’écran, on désire


calculer la somme ou le produit ou la moyenne ou chercher le minimum
ou le maximum de ces trois nombres.
- Le menu doit se présenter de la façon suivante:
---------------MENU-------------
1----------------Somme
2----------------Produit
3----------------Moyenne
4----------------Minimum
5----------------Maximum
14
Entrez votre choix
Instructions conditionnelles

Exercice: Calcul sur les nombres réels

- Objets d’entrée:
Trois nombres: X, Y et Z
Choix de l’opération : CH

- Objets de sortie:
Résultat de l’opération: R

15
Instructions conditionnelles

Exercice: Calcul sur les nombres réels

- Formules:
Selon la valeur de CH

• 1: R= X+Y+Z
• 2: R= X*Y*Z
• 3: R= (X + Y + Z)/3
• 4: R= min(X,Y,Z)
• 5: R= max (X, Y, Z)

16
Instructions conditionnelles

Algorithme Calcul;   Ecrire (‘3--------------Moyenne);


Var Ecrire (4---------------Minimum);
X, Y, Z, R: réels; Ecrire (5---------------Maximum);
Ch: caractère; Ecrire (‘Entrer votre choix’);
Début Lire (Ch);
Ecrire (‘Programme de calcul sur les cas Ch
nombres réels’); 1: R X + Y + Z
Ecrire (‘Entrer le premier nombre:’); 2: R X * Y * Z
Lire (X); 3: R (X + Y + Z)/3
Ecrire (‘Entrer le deuxième nombre:’); 4: Si XY alors
Lire (Y); R X;
Ecrire (‘Entrer le troisième nombre:’); Sinon
Lire (Z); R Y;
Ecrire (‘-----------MENU----------’); Finsi
Ecrire (‘1------------------Somme’); Si Z alors
Ecrire (‘2-------------------Produit); R Z; 17
Instructions conditionnelles

  Finsi
5: Si XY alors
R X;
Sinon
R Y;
Finsi
Si Z alors
R Z;
Finsi
Fincas;
Si (Ch 1) et (Ch 5) alors
Ecrire (‘Le résultat est:’ , R);
Sinon
Ecrire (‘Votre choix est mauvais’);
Finsi
Fin 18
Instructions conditionnelles

Exercice: Ordre de trois nombres

- Ecrire un algorithme permettant de saisir trois nombres entiers X, Y et Z


et les afficher à l’écran dans l’ordre croissant.
- Objets d’entrée:
Trois nombres: X, Y et Z.

- Objets de sortie:
L’ordre croissant des trois nombres X, Y et Z.

19
Instructions conditionnelles

 Algorithme ordre_croissant;   Ecrire (‘L’ordre croissant des nombres est :’ ,Y ‘,’ Z


Var ‘et,’ X);
X, Y, Z: réels; Sinon Si (Y) et (XZ)
Début Ecrire (‘L’ordre croissant des nombres est :’ ,Z ‘,’ X
Ecrire (‘Ordre croissant des trois nombres’); ‘et,’ Y);
Ecrire (‘Entrer le premier nombre:’); Sinon Si (ZX) et (XY)
Lire (X); Ecrire (‘L’ordre croissant des nombres
Ecrire (‘Entrer le deuxième nombre:’); est :’ ,Y ‘,’ X ‘et,’ Z);
Lire (Y); Sinon Si (XY) et (YZ)
Ecrire (‘L’ordre croissant des nombres
Ecrire (‘Entrer le troisième nombre:’);
est :’ ,Z ‘,’ Y ‘et,’ X);
Lire (Z);
Sinon Ecrire (‘Au moins deux
Si (YZ) et (ZX) nombres sont identiques’);
Ecrire (‘L’ordre croissant des nombres est :’ ,X Finsi
‘,’ Z ‘et,’ Y); Finsi
Sinon Si (Z) et (YX) Finsi
Ecrire (‘L’ordre croissant des nombres Finsi
est :’ ,X ‘,’ Y ‘et,’ Z); Finsi
20
Sinon Si (XZ) et (ZY) Finsi
Instructions conditionnelles

Exercice: Comparaison de deux dates

- Ecrire un algorithme qui compare deux dates représentées chacune par


trois entiers.
- Objets d’entrée:
Première date: j1/ m1/ a1.
Deuxième date: j2/m2/a2/
- Objets de sortie:
La date la plus récente.

21
Algorithme compare_date; Si a1>a2 alors
Var Ecrire (‘ la date 1 est plus grande
j1,m1,a1,j2,m2,a3: réels ; que la date 2 ’) ;
Debut Sinon si a1<a2 alors
Ecrire(‘************date 1 Ecrire(‘la date 2 est plus
***********‘) ; grande que la date 1 ’) ;
Ecrire(‘jour: ‘) ; Sinon Si m1>m2 alors
Lire(j1) ; Ecrire (‘ la date 1
Ecrire(‘Mois : ‘) ; est plus grande que la date 2 ’) ;
Lire(m1) ; Sinon si m1<m2 alors
Ecrire(‘Année : ‘) ; Ecrire(‘la date
Lire(a1) ; 2 est plus grande que la date 1 ’) ;
Ecrire(‘************date 2 Sinon Si j1>j2
***********‘) ; alors
Ecrire(‘jour: ‘) ; Ecrire (‘ la
Lire(j2) ; date 1 est plus grande que la date 2 ’);
Ecrire(‘Mois : ‘) ;
Lire(m2) ;
Ecrire(‘Année : ‘) ;
Lire(a2) ; 22
Sinon si j1<j2 alors
Ecrire(‘la
date 2 est plus grande que la date 1 ’) ;
Finsi
Finsi
Finsi
Finsi
finsi
fin

23
Instructions conditionnelles

Exercice: signe du produit et de la somme de deux nombres entiers


- Ecrire un algorithme permettant d’afficher le signe du produit et de la
somme sans avoir besoin d’’effectuer l’opération de multiplication ou
d’addition.
- Objets d’entrée:
Premier nombre: X1.
Deuxième nombre: X2.
- Objets de sortie:
Signe de multiplication.
Signe d’addition.
24
 Algorithme signe_somme_multiplication;  
Var Si (X10 ET X20) OU (X10 ET X20)
X1, X2: entiers; Alors
Début Ecrire (‘le signe de l’opération produit est
Ecrire (‘Le signe de la somme et la positif’);
multiplication’); Sinon
Ecrire (‘Entrer le premier nombre:’); Ecrire (‘le signe de l’opération produit est
Lire (X1); négatif’);
Ecrire (‘Entrer le deuxième nombre:’); Finsi
Lire (X2); Finsi
Si (X10 ET X20) OU (X20 ET X10 Fin
ET ) OU (X10 ET X20 ET ) Alors
Ecrire (‘le signe de l’opération somme
est positif’);
Sinon
Ecrire (‘le signe de l’opération somme
est négatif’);

25
Instructions conditionnelles

Exercice: Validité d’une date


- L’objectif est d’écrire un algorithme permettant de vérifier la saisie
correcte d’une date.
- Objets d’entrée:
Le jour: J.
Le mois: M.
L’année: A.
- Objets de sortie:
Validité ou non de la date.

26
 Algorithme validite_date;   Sinon Si (M=1) OU (M=3) OU
Var (M=5) OU (M=7) OU (M= 8) OU (M= 10 ) OU
J, M, A: entiers; (M= 12) ET (J0 ET J31) Alors
Début Ecrire (‘La date est valide’);
Ecrire (‘La validité de la date’); Finsi
Ecrire (‘Entrer le jour de la date:’); Finsi
Lire (J); Finsi
Ecrire (‘Entrer le mois de la date:’); Finsi
Lire (M); Finsi
Ecrire (‘Entrer l’année de la date:’); Finsi
Lire (A); Fin
Si (M=2) ET (J0 ET J28) Alors
Ecrire (‘La date est valide’);
Sinon Si (M= 4) OU (M= 6) OU (M= 9) OU
(M= 11) ET (J0 ET J30) Alors
Ecrire (‘La date est valide’);

27
Instructions conditionnelles

Exercice: Mini calculatrice


- Ecrire un algorithme permettant d’effectuer les opérations arithmétiques
suivantes: (+, -, *, /) et d’afficher le résultat final.
- Objets d’entrée:
Premier entier: X.
Deuxième entier: Y

- Objets de sortie:
Résultat de l’opération: somme, soustraction,
multiplication ou division
28
Algorithme mini_calculatrice;   1: Z X + Y;
Var Ecrire (‘Le resultat final est:’ Z);
X, Y: entiers; 2: Z X – Y;
Z: chaine de caractère; Ecrire (‘Le resultat final est:’ Z);
Début 3: Z X * Y;
Ecrire (‘Programmer une mini Ecrire (‘Le resultat final est:’ Z);
calculatrice:’); 4: Z X / Y;
Ecrire (‘Entrer le premier nombre:’); Ecrire (‘Le resultat final est:’ Z);
Lire (X); Fincas
Ecrire (‘Entrer le deuxième nombre:’); Fin
Lire (Y);
Ecrire (------------MENU-------------------);
Ecrire (‘Somme---------------------------1);
Ecrire (‘Soustraction---------------------2);
Ecrire (‘Multiplication-------------------3);
Ecrire (‘Division---------------------------4);
Ecrire (‘Somme---------------------------1);
Ecrire (‘Quel operation souhaitez-vous
effectuer?’);
Cas operation 29
Instructions répétitives (Les
boucles)

Objectifs de la quatrième partie:

Définir les instructions répétitives

Apprendre à les appliquer au bon endroit

30
Instructions répétitives (Les
boucles)

- Les primitives itératives constituent des boucles qui répètent d’un même
bloc d’instructions un certain nombre de fois.

- Ce nombre est soit précisé à l’avance soit il dépendra de l’évolution de


l’action algorithmique.

31
Instructions répétitives (Les
boucles)

- Plusieurs blocs doivent constituer une boucle pour qu’elle soit correcte:

Bloc d’initialisation • Point de départ des itérations.


de la boucle

Bloc de processus • Il contient l’ensemble des instructions à


itératif ou corps de
répéter à chaque itération.
la boucle

• Il s’agit d’un compteur qui fait évoluer


Bloc de progression
la boucle.

Bloc de test de • Il effectue le contrôle pour décider la


continuation continuation ou l’arrêt de la récurrence. 32
Instructions répétitives (Les
boucles)

- En programmation, il y a deux types de boucles:

Cas où le nombre Cas où le nombre


d’itération n’est pas d’itération est connu à
connu à l’avance l’avance

33
Instructions répétitives (Les
boucles)

- Premier cas: nombre d’itération inconnu à l’avance


- Il dépend de la réalisation d’une certaine condition au cours du
traitement. On distingue deux types d’instructions:

Test de contrôle effectué Test effectué à la fin de


au début de la boucle la boucle

34
Instructions répétitives (Les
boucles)

- L’instruction Tantque…faire…FinTantque:
- Les instructions ou les actions sont exécutées tant que la condition est
vérifiée.

35
Instructions répétitives (Les
boucles)

- L’instruction Tantque…faire…FinTantque:
- Le test est effectuée à l’entrée de la boucle, donc les instructions
peuvent être exécutées zéro fois si la condition est fausse à l’entrée de
la boucle.

- Dans le corps de la boucle, au moins une instruction doit nécessairement


faire évoluer les valeurs des variables testées dans la condition. Sinon la
boucle sera infinie.

36
Instructions répétitives (Les
boucles)

- L’instruction Tantque…faire…FinTantque:

 Algorithme Boucle_infinie;
Var - Dans le corps de cette
A: réel; boucle, rien ne fait évoluer
 Exemple 1: Début la variable A qui reste
A6 toujours inférieure à 10. Il y
aura donc un affichage de la
Tantque A10 Faire valeur 6 éternellement.
Ecrire (A);
FinTantque
Fin
37
Instructions répétitives (Les
boucles)

 Exemple 2: Ecrire un algorithme permettant de lire une suite de nombres


réels. L’objectif est d’afficher le plus petit élément de la suite ainsi que la
somme des éléments lus.

min
Eléments
Elt Somme_min
S

 Entrées: Suite des éléments lus : Elt


 Sorties : Le plus petit élément: min
La somme des éléments lus: S
38
Instructions répétitives (Les
boucles)

 Algorithme Somme_min;
Var
Elt, S, min: entiers;
Début
S0;
Lire (Elt);
Min Elt;
Tantque Elt0 Faire
S S + Elt;
 Exemple 2:
Si Eltmin Alors
min Elt;
Finsi
Lire (Elt);
FinTantque
Fin 39
Instructions répétitives (Les
boucles)

 Rappels:

 Une somme calculée par itération est obligatoirement initialisée par 0.

 Un produit calculée par itération est obligatoirement initialisée par 1.

40
Début

S=0

Lire
(Elt)

 L’organigramme:
Min=Elt

Non
 Elt0
Oui
Ecrire
S= S+ Elt (S)

Oui
 Eltmi Ecrire
n (min)
Non Min= Elt
Lire
Fin 41
(Elt)
Instructions répétitives (Les
boucles)

 Exemple 3: Ecrire un algorithme qui lit les noms des athlètes désirant
participer à un marathon et s’arrête lorsqu’il rencontre deux noms
consécutifs identiques. L’algorithme doit afficher à la fin le nombre des
participants.

Nbre_noms_lus:
Noms lus
nbr

 Entrées: Ancien nom (anc_nom) et nouveau nom (nov_nom).

 Sorties : Nombre de participants (Nbr).


42
Instructions répétitives (Les
boucles)

 Algorithme Nbre_noms_lus;
Var
anc_nom, nov_nom: chaine de 15
caractères;
Nbr: entier;
Début
 Exemple 3: Lire (anc_nom);
Lire (nov_nom);
Nbr 2;
Tantque anc_nomnov_nom Faire
anc_nom nov_nom;
Lire (nov_nom);
Nbr Nbr+1;
FinTantque
Fin 43

Vous aimerez peut-être aussi