⌂ Algorigrammes
Fiche 6 sur 13

Plusieurs conditions

Combiner des conditions avec et, ou, non, et enchaîner plusieurs choix.

Après cette fiche, vous saurez :

1Combiner deux conditions

Parfois, une seule comparaison ne suffit pas. Pour savoir si une personne a le droit à un tarif « adulte », il faut que l'âge soit au moins 18 ET au plus 64. On combine alors les conditions avec trois petits mots :

MotSigneSensExemple
ET&&les deux conditions doivent être vraiesage >= 18 && age <= 64
OU||au moins une des deux doit être vraiejour == 6 || jour == 7
NON!inverse la condition!(age >= 18)

Voici ce que donnent et et ou, selon que A et B sont vraies ou fausses :

ABA && B (et)A || B (ou)
vraivraivraivrai
vraifauxfauxvrai
fauxvraifauxvrai
fauxfauxfauxfaux

Le ET est exigeant (tout doit être vrai). Le OU est large (un seul suffit).

Début int jour "Jour de la semaine (1 à 7) :" jour jour == 6 || jour == 7 "Week-end : ouvert de 10 h à 18 h." "Semaine : ouvert de 8 h à 20 h." Fin oui non

Ce losange se lit : « le jour est le 6 ou le jour est le 7 ».

Attention

Deux erreurs à ne jamais faire.

2Plusieurs cas : la cascade

Quand il y a plus de deux possibilités, on enchaîne les losanges. Chaque sortie « non » mène au losange suivant.

Exemple : les amendes d'une bibliothèque, selon le nombre de jours de retard.

RetardAmende par jour
de 1 à 7 jours0,10 €
de 8 à 30 jours0,25 €
plus de 30 jours0,50 €
Début int jours double amende "Nombre de jours de retard :" jours jours >= 1 && jours <= 7 amende = jours * 0.10 jours >= 8 && jours <= 30 amende = jours * 0.25 amende = jours * 0.50 "Amende : {amende}" Fin oui non oui non

On lit le dessin de haut en bas :

  1. Si le retard est de 1 à 7 jours → amende faible. Fin des tests.
  2. Sinon, si le retard est de 8 à 30 jours → amende moyenne. Fin des tests.
  3. Sinon, c'est forcément plus de 30 jours → amende élevée.

En C#, c'est la suite if / else if / else :

if (jours >= 1 && jours <= 7)
{
    amende = jours * 0.10;
}
else if (jours >= 8 && jours <= 30)
{
    amende = jours * 0.25;
}
else
{
    amende = jours * 0.50;
}
Jours de retardAmende
10.1
70.7
82
307.5
3115.5
10050

3Simplifier une cascade

Quand on arrive au deuxième losange, on sait déjà que la réponse au premier était « non » : le retard est donc forcément supérieur à 7. Il est inutile de le vérifier encore. La condition du 2e losange peut donc se réduire à jours <= 30.

LosangeVersion complèteVersion simplifiée
1erjours >= 1 && jours <= 7jours <= 7
2ejours >= 8 && jours <= 30jours <= 30

Les deux versions donnent exactement les mêmes résultats (nous l'avons vérifié pour tous les retards de 1 à 119 jours). La version simplifiée est plus courte ; la version complète est plus facile à lire. À vous de choisir, mais restez cohérent.

Attention

Dans une cascade, l'ordre des losanges compte.

Si on testait d'abord jours <= 30, un retard de 5 jours répondrait « oui » et serait traité comme une amende moyenne, sans jamais arriver au test jours <= 7. Toujours commencer par le cas le plus précis.

4Les valeurs limites

Dans une cascade, les erreurs se cachent à la frontière entre deux tranches. Pour les amendes, testez toujours :

Que se passe-t-il pour 0 ou -5 jours ? Notre cascade les range dans la dernière tranche (la plus chère), ce qui n'a aucun sens. Pour l'éviter, on contrôle la saisie avant de calculer : c'est le sujet de la fiche 8.

5Retenir une réponse : le drapeau

Parfois, il faut se souvenir du résultat d'une vérification pour s'en servir plus loin dans le dessin. On utilise pour cela une variable bool (vrai ou faux), qu'on appelle un drapeau : levé (true) ou baissé (false).

bool ok = true;            // au départ, tout va bien

if (operateur == '/' && b == 0)
{
    ok = false;            // on baisse le drapeau : le calcul est impossible
}

if (ok)                    // plus loin : on ne calcule que si le drapeau est levé
{
    // ...
}

Dans un losange, on écrit simplement ok (c'est déjà une réponse oui ou non), et non ok == true. Vous retrouverez ce procédé dans l'exercice de la calculette.

À retenir

→Exercices

1Les amendes, version courteRecopier

Reproduisez cet algorigramme. Puis vérifiez avec 7, 8, 30 et 31 jours de retard que l'amende est la bonne.

Début int jours double amende "Nombre de jours de retard :" jours jours <= 7 amende = jours * 0.10 jours <= 30 amende = jours * 0.25 amende = jours * 0.50 "Amende : {amende}" Fin oui non oui non

Solution

Début int jours double amende "Nombre de jours de retard :" jours jours <= 7 amende = jours * 0.10 jours <= 30 amende = jours * 0.25 amende = jours * 0.50 "Amende : {amende}" Fin oui non oui non
Jours de retardAmende
70.7
82
307.5
3115.5

7 jours coûtent 0,70 € (tarif faible) et 8 jours coûtent 2 € (tarif moyen) : la frontière est bien au bon endroit. De même entre 30 et 31 jours.

2Deux tranches de plusModifier

La bibliothèque ajoute deux tranches :

  • de 31 à 90 jours : 0,50 € par jour ;
  • plus de 90 jours : 1 € par jour.

Modifiez l'algorigramme de l'exercice 1 pour tenir compte de ces quatre tranches.

Solution

Il faut un losange de plus dans la cascade : la dernière branche « non » ne suffit plus, elle doit elle-même séparer deux cas.

Début int jours double amende "Nombre de jours de retard :" jours jours <= 7 amende = jours * 0.10 jours <= 30 amende = jours * 0.25 jours <= 90 amende = jours * 0.50 amende = jours * 1 "Amende : {amende}" Fin oui non oui non oui non
Jours de retardAmende
70.7
307.5
3115.5
9045
9191
3Plus petit, plus grand ou entre les deux (syllabus P2·1)Créer

Dessinez l'algorigramme d'un programme qui demande un nombre et affiche s'il est plus petit que 10, plus grand que 20, ou entre les deux.

Solution

Trois cas, donc deux losanges en cascade. On regarde d'abord « plus petit que 10 » ; sinon, on regarde « plus grand que 20 » ; sinon, c'est forcément entre les deux.

Début int nombre "Entrez un nombre :" nombre nombre < 10 "Plus petit que 10" nombre > 20 "Plus grand que 20" "Entre 10 et 20" Fin oui non oui non
NombreCe qui s'affiche
5Plus petit que 10
9Plus petit que 10
10Entre 10 et 20
15Entre 10 et 20
20Entre 10 et 20
21Plus grand que 20

Les valeurs limites sont 10 et 20 : elles ne sont ni « plus petit que 10 », ni « plus grand que 20 ». Elles tombent donc dans « entre les deux ».

4La lettre a ou A (syllabus P2·2)Créer

Dessinez l'algorigramme d'un programme qui demande d'entrer la lettre « a » ou « A ». Si l'utilisateur a bien tapé l'une des deux, il affiche « Ok », sinon « Erreur ».

Indice : une lettre est un char, qui s'écrit entre apostrophes.

Solution

La condition est un ou : la lettre vaut 'a' ou la lettre vaut 'A'. Chaque côté du || est une comparaison complète :

Début char lettre "Entrez la lettre a ou A :" lettre lettre == 'a' || lettre == 'A' "Ok" "Erreur" Fin oui non
Lettre tapéeCe qui s'affiche
aOk
AOk
bErreur
BErreur

'a' et 'A' sont deux caractères différents pour l'ordinateur (leurs codes ASCII ne sont pas les mêmes) : c'est pourquoi il faut tester les deux.

5Le tarif de la piscineCréer

Dessinez l'algorigramme d'une piscine qui demande l'âge du visiteur et affiche son tarif :

ÂgeTarif
moins de 6 ansgratuit
de 6 à 17 ans5 euros
de 18 à 64 ans8 euros
65 ans et plus6 euros

Quelles valeurs limites allez-vous tester ?

Solution

Quatre cas, donc trois losanges en cascade :

Début int age int tarif "Âge du visiteur :" age age < 6 tarif = 0 age <= 17 tarif = 5 age <= 64 tarif = 8 tarif = 6 "Tarif : {tarif} euros" Fin oui non oui non oui non

Valeurs limites à tester : 5 et 6 (gratuit ou 5 euros), 17 et 18 (5 ou 8 euros), 64 et 65 (8 ou 6 euros).

6Le plus grand de trois nombres (syllabus P2·3)Créer

Dessinez l'algorigramme d'un programme qui demande trois nombres et affiche le plus grand.

Indice : on peut garder en mémoire « le plus grand vu jusqu'ici ».

Solution

On suppose d'abord que le premier nombre est le plus grand. Puis on le compare au deuxième, et au troisième : à chaque fois qu'un nombre est plus grand que celui qu'on garde, on le remplace.

Début int a int b int c int plus_grand "Entrez trois nombres" a, b, c plus_grand = a b > plus_grand plus_grand = b c > plus_grand plus_grand = c "Le plus grand est : " , plus_grand Fin oui non oui non
abcCe qui s'affiche
395Le plus grand est : 9
935Le plus grand est : 9
539Le plus grand est : 9
444Le plus grand est : 4
-5-2-9Le plus grand est : -2

Cette méthode fonctionne quel que soit l'ordre des nombres, et quand ils sont égaux. Elle se retrouvera dans les boucles (fiche 9) pour chercher le maximum d'une longue liste de valeurs.

Une autre méthode utilise des conditions avec &&, par exemple « a >= b && a >= c → a est le plus grand ». Elle demande plus de losanges : la solution ci-dessus est plus courte.

7Trois prénoms par ordre alphabétique (syllabus P2·4)Créer

Dessinez l'algorigramme d'un programme qui demande trois prénoms et les affiche par ordre alphabétique.

Indices : on compare les textes avec < et > (fiche 5), et on échange deux variables avec une variable auxiliaire (fiche 2).

Solution

Trois comparaisons suffisent. On compare a et b et on les échange s'ils sont dans le mauvais ordre ; on compare b et c, avec échange éventuel ; on recompare enfin a et b. Chaque échange utilise temp, comme à la fiche 2.

Début string a string b string c string temp "Entrez trois prénoms" a, b, c a > b temp = a a = b b = temp b > c temp = b b = c c = temp a > b temp = a a = b b = temp "{a}, {b}, {c}" Fin oui non oui non oui non

Déroulons-le avec Léa, Adam, Camille :

Étapeabctemp
déclarations????
saisie de a, b, cLéaAdamCamille?
temp = a ; a = b ; b = tempAdamLéaCamilleLéa
temp = b ; b = c ; c = tempAdamCamilleLéaLéa
abcCe qui s'affiche
LéaAdamCamilleAdam, Camille, Léa
CamilleLéaAdamAdam, Camille, Léa
AdamCamilleLéaAdam, Camille, Léa
zoéAdambobAdam, bob, zoé

Dans le dernier essai, « Adam » (qui commence par une majuscule) passe avant « bob » et « zoé » (des minuscules) : c'est l'ordre ASCII de la fiche 5. Avec des prénoms tous écrits de la même façon, l'ordre est celui de l'alphabet.

8La calculette (syllabus P2·5)Créer

Dessinez l'algorigramme d'une calculette. L'utilisateur entre un nombre, un opérateur (+, -, * ou /) puis un second nombre. Le programme affiche le calcul et son résultat, par exemple 6 / 3 = 2.

Attention à la division par zéro ! Si l'opérateur n'est pas l'un des quatre, il affiche « Opérateur inconnu ».

Solution

Dessin en trois temps :

  1. on écarte d'abord le cas division par zéro (un losange, avec un et) ;
  2. si tout va bien, on teste chaque opérateur à la suite (ces choix ne s'excluent pas en cascade : un seul peut être vrai) et on note, avec la variable connu, qu'on en a trouvé un ;
  3. on affiche le calcul, ou « Opérateur inconnu ».
Début double a double b char operateur double resultat bool ok = true bool connu = false "Nombre, opérateur (+ - * /), nombre" a, operateur, b operateur == '/' && b == 0 "Division par zéro impossible" ok = false ok operateur == '+' resultat = a + b connu = true operateur == '-' resultat = a - b connu = true operateur == '*' resultat = a * b connu = true operateur == '/' resultat = a / b connu = true connu "{a} {operateur} {b} = {resultat}" "Opérateur inconnu" Fin oui non oui oui non oui non oui non oui non oui non non
NombreOpérateurNombreCe qui s'affiche
6+36 + 3 = 9
6-36 - 3 = 3
6*36 * 3 = 18
6/36 / 3 = 2
6/0Division par zéro impossible
6%3Opérateur inconnu

Les variables ok et connu sont des booléens (vrai ou faux) : on les appelle des drapeaux. Elles retiennent un fait (« le calcul est possible », « l'opérateur est connu ») pour s'en servir plus loin dans le dessin.

Je sais faire

Une case qui coince ? Relisez la partie concernée avant de passer à la fiche suivante.

← Fiche 5 Fiche 7 : Répéter tant que →