Séance 2 — Les conditions

Décider, combiner, choisir entre plusieurs cas

Séance 2 d’Algorithmique : décider, combiner, choisir entre plusieurs cas.

Auteur

Dr. El Hadji Bassirou TOURÉ · DMI/FST/UCAD

Navigation conceptuelle

Amont. Les variables et leurs types (entier, réel, booléen, caractère, chaîne), l’affectation \(\leftarrow\), Lire, Écrire et la trace d’exécution (Séance 1). Jusqu’ici, toutes les lignes d’un algorithme s’exécutent, une fois chacune, dans l’ordre ; une condition décide, selon les données, quelles lignes s’exécutent.

Aval. Les boucles (Séance 3) testent une condition avant ou après chaque tour, et un Si placé dans une boucle compte ou retient une valeur ; la recherche dans un tableau (Séance 4) s’arrête sur une condition composée par ET.

Objectifs

Dérouler à la main un Si à un cas et à deux cas, et dire quel bloc est exécuté.
Évaluer une condition composée, membre par membre, à l’aide des tables de vérité de ET, OU, NON.
Appliquer les priorités des connecteurs et nier une condition (lois de De Morgan).
Choisir entre plusieurs cas par des Si imbriqués, une chaîne SinonSi ou Selon, et compter les tests évalués.
Vérifier une condition sur ses bornes, incluses ou exclues.
Repérer trois erreurs : la borne mal placée, le mauvais ordre des tests, la condition toujours vraie ; distinguer \(=\) de \(\leftarrow\).

Les conventions du pseudo-code

Tout le cours écrit ses algorithmes dans un même pseudo-code français, indépendant de tout langage de programmation. La Séance 1 en a fixé les instructions de base ; la présente séance y ajoute les comparaisons, les connecteurs logiques et les instructions de décision. Le tableau ci-dessous rassemble les conventions utilisées dans la suite ; celles de la seconde partie sont nouvelles.

Écriture	Sens
\(x\leftarrow e\)	\(x\) reçoit la valeur de l’expression \(e\) (se lit « \(x\) reçoit \(e\) »)
Lire `n` ; Écrire `"prix :"`, `p`	lecture au clavier, une valeur par ligne ; écriture des valeurs séparées par une espace, puis passage à la ligne
\(+\), \(-\), \(\times\), \(/\) ; div, mod	opérations ; quotient et reste de la division entière (\(7\) div \(2=3\), \(7\) mod \(2=1\))
réel lu ou écrit	avec une virgule et au moins une décimale : `13,5`, `12,0`
booléen écrit	Écrire écrit `vrai` ou `faux`
\(=\), \(\neq\), \(<\), \(\leq\), \(>\), \(\geq\)	comparaisons ; le résultat est une valeur booléenne, vrai ou faux
`b` \(\leftarrow\) `a mod 4 = 0`	une variable booléenne reçoit le résultat d’une comparaison
caractère, chaîne	comparés par \(=\) et \(\neq\) seulement (`rep = "oui"`) ; le pseudo-code du cours ne compare pas deux chaînes par \(<\), \(\leq\), \(>\), \(\geq\)
NON \(C\) ; \(C_1\) ET \(C_2\) ; \(C_1\) OU \(C_2\)	connecteurs logiques ; priorités : comparaisons, puis NON, puis ET, puis OU
\(C_1\) ET \(C_2\) ; \(C_1\) OU \(C_2\)	les deux membres sont toujours évalués, le premier puis le second
\(0\leq x\leq20\)	s’écrit `x` \(\geq\) `0` ET `x` \(\leq\) `20` ; la double inégalité n’est pas une écriture du pseudo-code
Si \(C\) Alors … [Sinon …] FinSi	décision à un cas, ou à deux cas avec Sinon
Si … SinonSi \(C_2\) Alors … FinSi	chaîne de tests : le premier vrai choisit son bloc ; un seul FinSi
Selon \(e\) Faire, Cas \(v\) :, Autrement :, FinSelon	\(e\) évaluée une fois et comparée aux valeurs des Cas, dans l’ordre
Cas \(v_1\), \(v_2\) :	équivaut à \(e=v_1\) OU \(e=v_2\) ; comme pour tout OU, toutes les comparaisons du Cas sont évaluées
erreur	une division par zéro (div, mod ou \(/\) par 0) arrête l’exécution
retrait de deux espaces, mot de fin	délimitent les blocs d’un Si ou d’un Selon

Les lignes des algorithmes sont numérotées. Une trace d’exécution les suit dans l’ordre où elles sont exécutées : chaque ligne du tableau de trace est un pas, qui donne le numéro de la ligne exécutée, l’état des variables après ce pas (la variable affectée au pas est en gras), le résultat du test quand la ligne en contient un, et ce qu’écrit Écrire. La ligne Selon produit un pas, où la valeur examinée est relevée ; les lignes Sinon, Autrement, FinSi et FinSelon ne produisent pas de pas : elles marquent le début ou la fin d’un bloc.

La décision à un cas et à deux cas

Pourquoi décider

Un algorithme de la Séance 1 exécute toutes ses lignes, une fois chacune, dans l’ordre où elles sont écrites : il fait le même travail quelles que soient les données. Or la plupart des traitements dépendent des données : une livraison est offerte au-delà d’un montant, une mention dépend de la moyenne, le prix d’un billet dépend du trajet. Une condition est une expression dont la valeur est vrai ou faux ; une instruction de décision l’évalue au moment où l’exécution l’atteint et choisit, d’après sa valeur, les lignes à exécuter ensuite.

Le Si à un cas

Instruction Si … Alors … FinSi

Si \(C\) Alors \(B\) FinSi évalue la condition \(C\) ; si elle est vraie, le bloc \(B\) est exécuté, puis l’exécution passe à la ligne qui suit FinSi ; si elle est fausse, \(B\) est sauté et l’exécution passe directement à la ligne qui suit FinSi. Le bloc \(B\) est exécuté au plus une fois.

Une boutique de Dakar facture la livraison 1000 F et l’offre à partir de 20000 F d’achat (règle illustrative). L’algorithme suivant donne d’abord aux frais leur valeur par défaut, puis les annule dans le seul cas où le montant atteint le seuil : un Si à un cas convient à cette tâche, car le cas contraire ne demande aucune action. L’organigramme ci-dessous dessine ce choix : la branche « faux » rejoint directement la suite.

Exemple pas à pas : la livraison offerte

L’entrée au clavier est 25000.

Lire montant
frais ← 1000
Si montant ≥ 20000 Alors
  frais ← 0
FinSi
Écrire "à payer :", montant + frais

Pas	Ligne	Instruction	`montant`	`frais`	Test	Écrit
1	1	`Lire montant`	25000
2	2	`frais ← 1000`	25000	1000
3	3	`Si montant ≥ 20000 Alors`	25000	1000	vrai
4	4	`frais ← 0`	25000	0
5	6	`Écrire “à payer :”, montant + frais`	25000	0		`à payer : 25000`

Le pas 1 lit le montant, le pas 2 fixe les frais à 1000. Au pas 3, le test \(25000\geq20000\) est vrai : l’exécution entre dans le bloc et la ligne 4 annule les frais (pas 4). La ligne 5, FinSi, ne produit pas de pas ; la ligne 6 écrit à payer : 25000. Avec l’entrée 15000, le test est faux et la ligne 4 n’est jamais exécutée :

Pas	Ligne	Instruction	`montant`	`frais`	Test	Écrit
1	1	`Lire montant`	15000
2	2	`frais ← 1000`	15000	1000
3	3	`Si montant ≥ 20000 Alors`	15000	1000	faux
4	6	`Écrire “à payer :”, montant + frais`	15000	1000		`à payer : 16000`

La trace saute de la ligne 3 à la ligne 6, et les frais gardent leur valeur par défaut : l’algorithme écrit à payer : 16000. Les deux figures suivantes montrent le pas 3 de chacune des deux exécutions : la même ligne est surlignée, mais le test vaut vrai en haut (25000), faux en bas (15000), et c’est ce résultat qui décide de la ligne surlignée au pas suivant.

Pour le montant 20000, exactement égal au seuil, \(20000\geq20000\) est vrai et la livraison est offerte : le symbole \(\geq\) inclut la borne. Ce cas, appelé cas limite, est celui où une erreur de comparaison se voit (section 5).

Le Si à deux cas

Quand chacun des deux cas demande sa propre action, le Si reçoit un second bloc, introduit par Sinon.

Instruction Si … Alors … Sinon … FinSi

Si \(C\) Alors \(B_1\) Sinon \(B_2\) FinSi évalue \(C\) ; si elle est vraie, \(B_1\) est exécuté ; sinon, \(B_2\) est exécuté ; dans les deux cas, l’exécution passe ensuite à la ligne qui suit FinSi. À chaque exécution, un et un seul des deux blocs est exécuté.

Exemple pas à pas : pair ou impair

Un entier \(n\) est pair quand le reste de sa division par 2 est nul : la condition s’écrit n mod 2 = 0. L’entrée est 7.

Lire n
Si n mod 2 = 0 Alors
  Écrire n, "est pair"
Sinon
  Écrire n, "est impair"
FinSi
Écrire "fin"

Pas	Ligne	Instruction	`n`	Test	Écrit
1	1	`Lire n`	7
2	2	`Si n mod 2 = 0 Alors`	7	faux
3	5	`Écrire n, “est impair”`	7		`7 est impair`
4	7	`Écrire “fin”`	7		`fin`

Au pas 2, \(7\) mod \(2=1\), et la comparaison \(1=0\) est fausse : le bloc Alors (ligne 3) est sauté et l’exécution passe au bloc Sinon, qui écrit 7 est impair (pas 3). La ligne 6, FinSi, renvoie à la ligne 7, exécutée dans tous les cas : elle écrit fin. Pour l’entrée 10, la ligne 3 serait exécutée et la ligne 5 sautée ; pour 0, \(0\) mod \(2=0\) et 0 est pair.

Condition, booléen et affectation

Une comparaison comme n mod 2 = 0 est une expression comme une autre : elle a une valeur, vrai ou faux, du type booléen de la Séance 1. Cette valeur peut être rangée dans une variable booléenne, puis testée : après pair \(\leftarrow\) n mod 2 = 0, la condition Si pair Alors teste la valeur de pair. Nommer ainsi une condition rend un algorithme plus lisible quand la condition est longue ou sert plusieurs fois.

\(=\) teste, \(\leftarrow\) affecte

x = 5 est une comparaison : elle vaut vrai ou faux et ne modifie aucune variable. x \(\leftarrow\) 5 est une affectation : elle donne la valeur 5 à x et n’a pas de valeur de vérité. Si x \(\leftarrow\) 5 Alors n’a donc pas de sens, et x = x + 1 seule n’est pas une instruction du pseudo-code : une comparaison seule ne modifie aucune variable. Dans plusieurs langages de programmation, l’affectation s’écrit avec le signe \(=\) ; le pseudo-code réserve \(=\) à la comparaison.

Les conditions composées

ET, OU, NON et leurs tables de vérité

Une règle réelle combine souvent plusieurs comparaisons : « une note est valide si elle est au moins égale à 0 et au plus égale à 20 », « le tarif est réduit pour un étudiant de moins de 26 ans ou pour une personne d’au moins 60 ans ». Les connecteurs logiques ET, OU et NON construisent une condition à partir d’autres conditions ; la valeur du résultat ne dépend que des valeurs des membres, et se lit dans une table de vérité.

\(C\)	NON \(C\)
vrai	faux
faux	vrai

\(C_1\)	\(C_2\)	\(C_1\) ET \(C_2\)	\(C_1\) OU \(C_2\)
vrai	vrai	vrai	vrai
vrai	faux	faux	vrai
faux	vrai	faux	vrai
faux	faux	faux	faux

Connecteurs logiques

\(C_1\) ET \(C_2\) est vrai si les deux membres sont vrais ; \(C_1\) OU \(C_2\) est vrai si au moins un des deux membres est vrai, les deux compris ; NON \(C\) est vrai si \(C\) est faux. Avec deux membres, la table compte \(2\times2=4\) lignes ; avec trois, \(2\times2\times2=8\).

Le OU du pseudo-code est inclusif : il est vrai quand les deux membres le sont. Le « ou » de la langue courante est parfois exclusif (« fromage ou dessert ») ; en algorithmique, une condition « l’un ou l’autre, mais pas les deux » s’écrit autrement, par exemple \((C_1\) OU \(C_2)\) ET NON \((C_1\) ET \(C_2)\).

Priorités et parenthèses

Dans une condition sans parenthèses, les comparaisons sont évaluées d’abord, puis NON, puis ET, puis OU : c’est la même hiérarchie que celle de la multiplication, prioritaire sur l’addition. Ainsi age < 26 ET etu = 1 OU age ≥ 60 se lit (age < 26 ET etu = 1) OU age ≥ 60. Les parenthèses imposent un autre ordre : age < 26 ET (etu = 1 OU age ≥ 60) est une autre condition, qui donne un autre résultat pour une personne de 64 ans (section 6.1). Écrire les parenthèses, même quand la priorité les rend inutiles, évite au lecteur d’avoir à s’en souvenir.

Exemple pas à pas : l’année bissextile

Dans le calendrier grégorien, une année est bissextile si elle est multiple de 4 sans être multiple de 100, ou si elle est multiple de 400. La règle se traduit en deux conditions composées : p retient la première partie (« multiple de 4 ET non multiple de 100 »), b la règle entière. L’entrée est 1900.

Lire a
p ← a mod 4 = 0 ET a mod 100 ≠ 0
b ← p OU a mod 400 = 0
Si b Alors
  Écrire a, "bissextile"
Sinon
  Écrire a, "non bissextile"
FinSi

Pas	Ligne	Instruction	`a`	`p`	`b`	Test	Écrit
1	1	`Lire a`	1900
2	2	`p ← a mod 4 = 0 ET a mod 100 ≠ 0`	1900	faux
3	3	`b ← p OU a mod 400 = 0`	1900	faux	faux
4	4	`Si b Alors`	1900	faux	faux	faux
5	7	`Écrire a, “non bissextile”`	1900	faux	faux		`1900 non bissextile`

Au pas 2, les deux membres du ET sont évalués : \(1900\) mod \(4=0\) est vrai, mais \(1900\) mod \(100=0\), donc a mod 100 ≠ 0 est faux ; vrai ET faux donne faux. Au pas 3, \(1900\) mod \(400=300\) : le second membre du OU est faux aussi, et faux OU faux donne faux. Le test du pas 4 porte sur la variable booléenne b elle-même : elle vaut faux, le bloc Sinon écrit 1900 non bissextile. Le tableau suivant reprend l’évaluation pour quatre années :

`a`	`a mod 4 = 0`	`a mod 100 ≠ 0`	`p` (ET)	`a mod 400 = 0`	`b` (OU)
1900	vrai	faux	faux	faux	faux
2000	vrai	faux	faux	vrai	vrai
2026	faux	vrai	faux	faux	faux
2028	vrai	vrai	vrai	faux	vrai

Chacune des quatre années emprunte un chemin différent de la table de vérité : 2000 est bissextile par le second membre du OU, 2028 par le premier. Une vérification complète de la condition passe par ces quatre profils.

L’évaluation des deux membres

Le cours fixe une règle qui compte dès qu’un membre peut provoquer une erreur : ET et OU évaluent toujours leurs deux membres, même quand le premier détermine déjà le résultat. L’algorithme suivant teste si \(d\) divise \(n\) ; il croit se protéger d’une division par zéro en testant d’abord \(d\neq0\). Les entrées sont 12 puis 0.

Lire n
Lire d
Si d ≠ 0 ET n mod d = 0 Alors
  Écrire d, "divise", n
Sinon
  Écrire d, "ne divise pas", n
FinSi

Pas	Ligne	Instruction	`n`	`d`	Test	Écrit
1	1	`Lire n`	12
2	2	`Lire d`	12	0
3	3	`Si d ≠ 0 ET n mod d = 0 Alors`	12	0	erreur	arrêt : division par zéro

Le premier membre, \(0\neq0\), est faux ; le résultat du ET est donc déjà connu. Mais le second membre est évalué malgré tout, et 12 mod 0 demande une division par zéro : l’exécution s’arrête à la ligne 3, sans rien écrire. La figure montre ce pas : la ligne fautive est surlignée en rouge.

La protection s’écrit avec deux Si imbriqués : le second test n’est évalué que si le premier est vrai.

Lire n
Lire d
Si d ≠ 0 Alors
  Si n mod d = 0 Alors
    Écrire d, "divise", n
  Sinon
    Écrire d, "ne divise pas", n
  FinSi
Sinon
  Écrire "division par zéro"
FinSi

Pas	Ligne	Instruction	`n`	`d`	Test	Écrit
1	1	`Lire n`	12
2	2	`Lire d`	12	0
3	3	`Si d ≠ 0 Alors`	12	0	faux
4	10	`Écrire “division par zéro”`	12	0		`division par zéro`

Pour les mêmes entrées, le test du pas 3 est faux, le bloc Alors entier (lignes 4 à 8) est sauté, et la ligne 10 écrit division par zéro. Avec \(d=5\), le premier test est vrai et le second, \(12\) mod \(5=2\), est faux :

Pas	Ligne	Instruction	`n`	`d`	Test	Écrit
1	1	`Lire n`	12
2	2	`Lire d`	12	5
3	3	`Si d ≠ 0 Alors`	12	5	vrai
4	4	`Si n mod d = 0 Alors`	12	5	faux
5	7	`Écrire d, “ne divise pas”, n`	12	5		`5 ne divise pas 12`

Une convention du cours

Plusieurs langages (C, Java, Python) n’évaluent le second membre que si le premier ne détermine pas le résultat (« évaluation paresseuse »). Le pseudo-code du cours ne fait pas cette hypothèse : un algorithme écrit avec cette règle reste juste quel que soit le langage dans lequel il est traduit ensuite. Un membre qui ne doit être évalué que sous condition va dans un Si imbriqué.

La négation d’une condition

Il faut souvent écrire le contraire d’une condition : le cas « invalide » d’une note, le « plein tarif » d’une réduction. Les deux lois de De Morgan donnent cette négation sans NON : \[\textbf{NON}\,(C_1\ \textbf{ET}\ C_2) = (\textbf{NON}\,C_1)\ \textbf{OU}\ (\textbf{NON}\,C_2), \qquad \textbf{NON}\,(C_1\ \textbf{OU}\ C_2) = (\textbf{NON}\,C_1)\ \textbf{ET}\ (\textbf{NON}\,C_2).\] Nier un ET donne un OU des négations, et inversement ; la négation d’une comparaison change son opérateur : NON \((x\geq0)\) s’écrit \(x<0\), NON \((x=y)\) s’écrit \(x\neq y\). Ainsi, une note est invalide quand NON (note ≥ 0 ET note ≤ 20), c’est-à-dire note < 0 OU note > 20. Les deux lois se vérifient sur les quatre lignes de la table de vérité.

Nier une comparaison

La négation de \(x>20\) est \(x\leq20\), et non \(x<20\) : la valeur 20 elle-même change de côté. Autre erreur répandue : nier note ≥ 0 ET note ≤ 20 en note < 0 ET note > 20, condition qui n’est jamais vraie, puisqu’aucun nombre n’est à la fois négatif et supérieur à 20.

Plusieurs cas

Des Si imbriqués : la mention au baccalauréat

Une décision peut avoir plus de deux issues. Au baccalauréat sénégalais, le candidat est admis au premier groupe avec une moyenne \(m\) d’au moins 10 sur 20 ; la mention est Passable de 10 à moins de 12, Assez bien de 12 à moins de 14, Bien de 14 à moins de 16, Très bien à partir de 16. Sous 10, il n’est pas admis au premier groupe (de 8 à moins de 10, il passe le second groupe). L’algorithme écrit la mention, ou non admis sous 10. Le bloc d’un Si est une suite d’instructions quelconque ; il peut contenir lui-même un Si. Placé dans le bloc Sinon, le second Si n’est évalué que si la première condition est fausse : au moment du test \(m<12\), on sait déjà que \(m\geq10\). L’entrée est la moyenne 13,5, un réel.

Lire m
Si m < 10 Alors
  Écrire "non admis"
Sinon
  Si m < 12 Alors
    Écrire "Passable"
  Sinon
    Si m < 14 Alors
      Écrire "Assez bien"
    Sinon
      Si m < 16 Alors
        Écrire "Bien"
      Sinon
        Écrire "Très bien"
      FinSi
    FinSi
  FinSi
FinSi

Pas	Ligne	Instruction	`m`	Test	Écrit
1	1	`Lire m`	13,5
2	2	`Si m < 10 Alors`	13,5	faux
3	5	`Si m < 12 Alors`	13,5	faux
4	8	`Si m < 14 Alors`	13,5	vrai
5	9	`Écrire “Assez bien”`	13,5		`Assez bien`

Les tests des pas 2 et 3 sont faux : l’exécution descend, à chaque fois, dans le bloc Sinon du Si courant. Le test du pas 4, \(13{,}5<14\), est vrai et la ligne 9 écrit Assez bien ; le Si de la ligne 11 n’est jamais évalué. Quatre Si donnent cinq issues : la dernière, « Très bien », est le Sinon du dernier test. Mais chaque niveau d’imbrication ajoute un retrait et un FinSi, et le texte dérive vers la droite.

La chaîne SinonSi

Chaîne SinonSi

Si \(C_1\) Alors \(B_1\) SinonSi \(C_2\) Alors \(B_2\) … SinonSi \(C_k\) Alors \(B_k\) Sinon \(B\) FinSi évalue \(C_1\), \(C_2\), …, \(C_k\) dans l’ordre ; la première condition vraie fait exécuter son bloc, et les conditions suivantes ne sont pas évaluées ; si aucune n’est vraie, le bloc Sinon, facultatif, est exécuté. Au plus un bloc est exécuté, exactement un s’il y a un Sinon. SinonSi \(C_2\) Alors remplace Sinon suivi de Si \(C_2\) Alors ; un seul FinSi ferme toute la chaîne.

Exemple pas à pas : la mention par une chaîne SinonSi

Lire m
Si m < 10 Alors
  Écrire "non admis"
SinonSi m < 12 Alors
  Écrire "Passable"
SinonSi m < 14 Alors
  Écrire "Assez bien"
SinonSi m < 16 Alors
  Écrire "Bien"
Sinon
  Écrire "Très bien"
FinSi

Pas	Ligne	Instruction	`m`	Test	Écrit
1	1	`Lire m`	13,5
2	2	`Si m < 10 Alors`	13,5	faux
3	4	`SinonSi m < 12 Alors`	13,5	faux
4	6	`SinonSi m < 14 Alors`	13,5	vrai
5	7	`Écrire “Assez bien”`	13,5		`Assez bien`

La trace est celle des Si imbriqués, aux numéros de ligne près : les trois mêmes tests, dans le même ordre, avec les mêmes résultats. Au pas 4, le premier test vrai fait exécuter son bloc ; le test \(m<16\) de la ligne 8 n’est pas évalué. Les deux figures montrent les pas 3 et 4 : la ligne surlignée descend de SinonSi en SinonSi tant que les tests sont faux.

Le nombre de tests évalués dépend de la moyenne : un seul pour \(m<10\), quatre au plus. Le tableau suivant le donne pour huit moyennes, pour cette chaîne et pour la chaîne écrite dans l’ordre inverse (m ≥ 16 d’abord, puis m ≥ 14, m ≥ 12, m ≥ 10) ; les deux chaînes écrivent la même mention.

`m`	8,0	10,0	11,5	12,0	13,5	15,0	16,0	19,0
mention	non admis	Passable	Passable	Assez bien	Assez bien	Bien	Très bien	Très bien
tests, chaîne croissante	1	2	2	3	3	4	4	4
tests, chaîne décroissante	4	4	4	3	3	2	1	1

Une chaîne évalue en moyenne d’autant moins de tests que les cas les plus fréquents sont placés en tête ; le résultat, lui, ne dépend pas de ce choix tant que chaque test est écrit pour sa place dans la chaîne.

Selon … Cas … Autrement

Quand tous les tests d’une chaîne comparent une même valeur à des constantes, le pseudo-code propose une écriture plus compacte. Le prix d’un billet du TER de Dakar dépend du nombre de zones traversées, 1, 2 ou 3 ; les prix de l’exemple, 500, 1000 et 1500 F, sont illustratifs.

Instruction Selon

Selon \(e\) Faire évalue l’expression \(e\) une fois, puis la compare aux valeurs des lignes Cas, dans l’ordre : le premier Cas égal fait exécuter son bloc, et les suivants ne sont pas comparés ; si aucun n’est égal, le bloc Autrement, facultatif, est exécuté. Cas \(v_1\), \(v_2\) : accepte plusieurs valeurs et équivaut à \(e=v_1\) OU \(e=v_2\) ; comme pour tout OU, toutes les comparaisons du Cas sont évaluées. L’instruction se termine par FinSelon. Elle équivaut à une chaîne SinonSi dont chaque test est \(e=v\), Autrement jouant le rôle de Sinon.

Lire z
Selon z Faire
  Cas 1 :
    prix ← 500
  Cas 2 :
    prix ← 1000
  Cas 3 :
    prix ← 1500
  Autrement :
    prix ← 0  // zone inconnue
FinSelon
Écrire "prix :", prix

Lire z
Si z = 1 Alors
  prix ← 500
SinonSi z = 2 Alors
  prix ← 1000
SinonSi z = 3 Alors
  prix ← 1500
Sinon
  prix ← 0  // zone inconnue
FinSi
Écrire "prix :", prix

L’entrée est 2. Avec Selon, la valeur de z est examinée une fois au pas 2, puis comparée à 1 (faux) et à 2 (vrai) :

Pas	Ligne	Instruction	`z`	`prix`	Test	Écrit
1	1	`Lire z`	2
2	2	`Selon z Faire`	2		vaut 2
3	3	`Cas 1 :`	2		faux
4	5	`Cas 2 :`	2		vrai
5	6	`prix ← 1000`	2	1000
6	12	`Écrire “prix :”, prix`	2	1000		`prix : 1000`

La version SinonSi fait les deux mêmes comparaisons :

Pas	Ligne	Instruction	`z`	`prix`	Test	Écrit
1	1	`Lire z`	2
2	2	`Si z = 1 Alors`	2		faux
3	4	`SinonSi z = 2 Alors`	2		vrai
4	5	`prix ← 1000`	2	1000
5	11	`Écrire “prix :”, prix`	2	1000		`prix : 1000`

Pour une valeur qui ne correspond à aucun Cas, comme 4, les trois comparaisons sont fausses et le bloc Autrement est exécuté. Comme la ligne Sinon de la chaîne équivalente, la ligne Autrement ne produit pas de pas : la trace passe du dernier Cas (ligne 7) à la ligne 10 :

Pas	Ligne	Instruction	`z`	`prix`	Test	Écrit
1	1	`Lire z`	4
2	2	`Selon z Faire`	4		vaut 4
3	3	`Cas 1 :`	4		faux
4	5	`Cas 2 :`	4		faux
5	7	`Cas 3 :`	4		faux
6	10	`prix ← 0 // zone inconnue`	4	0
7	12	`Écrire “prix :”, prix`	4	0		`prix : 0`

Les deux écritures font les mêmes comparaisons dans le même ordre : pour 0, 1, 2, 3 et 4, elles donnent les mêmes prix (0, 500, 1000, 1500, 0), avec une, deux ou trois comparaisons selon la valeur. Selon ne convient qu’aux comparaisons d’égalité avec des constantes : les intervalles de la mention demandent une chaîne SinonSi.

Cas limites et erreurs fréquentes

Une condition fausse ne provoque, en général, aucun arrêt : l’algorithme exécute un autre bloc que celui qui était voulu, et écrit un résultat faux sans le signaler. Ces erreurs se concentrent en trois endroits : les bornes, l’ordre des tests, la construction de la condition.

Les bornes incluses ou exclues

Une comparaison partage les valeurs en deux ; la borne elle-même tombe d’un côté ou de l’autre selon l’opérateur : \(m<12\) exclut 12, \(m\leq12\) l’inclut. La grille des mentions place chaque borne dans la mention supérieure : 12 donne « Assez bien ».

La chaîne de la section 4.3, écrite avec \(<\), respecte cette grille. Pour la moyenne 12,0, son troisième test est le premier vrai :

Pas	Ligne	Instruction	`m`	Test	Écrit
1	1	`Lire m`	12,0
2	2	`Si m < 10 Alors`	12,0	faux
3	4	`SinonSi m < 12 Alors`	12,0	faux
4	6	`SinonSi m < 14 Alors`	12,0	vrai
5	7	`Écrire “Assez bien”`	12,0		`Assez bien`

La même chaîne écrite avec \(\leq\) (m ≤ 12, m ≤ 14, m ≤ 16) arrête la chaîne un test plus tôt et écrit Passable :

Lire m
Si m < 10 Alors
  Écrire "non admis"
SinonSi m ≤ 12 Alors
  Écrire "Passable"
SinonSi m ≤ 14 Alors
  Écrire "Assez bien"
SinonSi m ≤ 16 Alors
  Écrire "Bien"
Sinon
  Écrire "Très bien"
FinSi

Pas	Ligne	Instruction	`m`	Test	Écrit
1	1	`Lire m`	12,0
2	2	`Si m < 10 Alors`	12,0	faux
3	4	`SinonSi m ≤ 12 Alors`	12,0	vrai
4	5	`Écrire “Passable”`	12,0		`Passable`

Au pas 3, les deux versions examinent la même valeur, 12,0, mais le test vaut faux en haut (\(12{,}0<12\)) et vrai en bas (\(12{,}0\leq12\)). La version fautive ne se trompe que sur les bornes :

`m`	11,5	12,0	13,0	14,0	16,0	17,0
avec \(<\) (correct)	Passable	Assez bien	Assez bien	Bien	Très bien	Très bien
avec \(\leq\) (fautif)	Passable	Passable	Assez bien	Assez bien	Bien	Très bien

Une vérification sur 11,5, 13,0 ou 17,0 ne détecte rien : seules les valeurs 12,0, 14,0 et 16,0 révèlent l’erreur. D’où la règle : une condition se vérifie sur chaque borne et sur une valeur de chaque côté de chaque borne.

L’ordre des tests

Dans une chaîne SinonSi, un test n’est évalué que si tous les précédents sont faux ; il hérite donc de ce que ces tests ont exclu. L’algorithme suivant écrit les conditions de la grille « à partir de », mais dans l’ordre croissant. L’entrée est 17,0.

Lire m
Si m ≥ 10 Alors
  Écrire "Passable"
SinonSi m ≥ 12 Alors
  Écrire "Assez bien"
SinonSi m ≥ 14 Alors
  Écrire "Bien"
SinonSi m ≥ 16 Alors
  Écrire "Très bien"
Sinon
  Écrire "non admis"
FinSi

Pas	Ligne	Instruction	`m`	Test	Écrit
1	1	`Lire m`	17,0
2	2	`Si m ≥ 10 Alors`	17,0	vrai
3	3	`Écrire “Passable”`	17,0		`Passable`

Le premier test, \(17{,}0\geq10\), est vrai : l’algorithme écrit Passable et la chaîne s’arrête. Tous les tests sont justes pris isolément, mais le premier, trop large, capte toutes les moyennes d’au moins 10 : les lignes 5, 7 et 9 ne sont jamais exécutées. Pour 8,0, 11,0, 13,0, 15,0 et 17,0, l’algorithme écrit non admis, puis quatre fois Passable. La correction place le test le plus restrictif en tête :

Lire m
Si m ≥ 16 Alors
  Écrire "Très bien"
SinonSi m ≥ 14 Alors
  Écrire "Bien"
SinonSi m ≥ 12 Alors
  Écrire "Assez bien"
SinonSi m ≥ 10 Alors
  Écrire "Passable"
Sinon
  Écrire "non admis"
FinSi

Pas	Ligne	Instruction	`m`	Test	Écrit
1	1	`Lire m`	17,0
2	2	`Si m ≥ 16 Alors`	17,0	vrai
3	3	`Écrire “Très bien”`	17,0		`Très bien`

Deux ordres sont corrects pour une grille d’intervalles : les bornes croissantes avec \(<\) (section 4.3), ou les bornes décroissantes avec \(\geq\). Le mélange, bornes croissantes avec \(\geq\), est faux.

La condition toujours vraie

Pour vérifier qu’une note est comprise entre 0 et 20, la condition suivante relie les deux comparaisons par OU. L’entrée est 25.

Lire note
Si note ≥ 0 OU note ≤ 20 Alors
  Écrire "note valide :", note
Sinon
  Écrire "note invalide :", note
FinSi

Pas	Ligne	Instruction	`note`	Test	Écrit
1	1	`Lire note`	25
2	2	`Si note ≥ 0 OU note ≤ 20 Alors`	25	vrai
3	3	`Écrire “note valide :”, note`	25		`note valide : 25`

\(25\geq0\) est vrai ; le OU est donc vrai, et la note 25 est déclarée valide. Tout nombre est soit au moins égal à 0, soit au plus égal à 20 (souvent les deux) : la condition est toujours vraie, et la ligne 5 n’est jamais exécutée. Un intervalle demande que les deux comparaisons soient vraies ensemble : c’est un ET.

Lire note
Si note ≥ 0 ET note ≤ 20 Alors
  Écrire "note valide :", note
Sinon
  Écrire "note invalide :", note
FinSi

Pas	Ligne	Instruction	`note`	Test	Écrit
1	1	`Lire note`	25
2	2	`Si note ≥ 0 ET note ≤ 20 Alors`	25	faux
3	5	`Écrire “note invalide :”, note`	25		`note invalide : 25`

Avec ET, 25 est refusé ; la borne 20 est acceptée, puisque \(20\geq0\) et \(20\leq20\) sont vrais :

Pas	Ligne	Instruction	`note`	Test	Écrit
1	1	`Lire note`	20
2	2	`Si note ≥ 0 ET note ≤ 20 Alors`	20	vrai
3	3	`Écrire “note valide :”, note`	20		`note valide : 20`

De même, une condition ET entre deux comparaisons incompatibles, comme note < 0 ET note > 20, est toujours fausse : son bloc n’est jamais exécuté. Dans les deux cas, un bloc d’algorithme qu’aucune entrée n’atteint est le signe d’une condition mal construite.

Méthode de vérification d’une décision

Relever les bornes de chaque condition et, pour chacune, l’opérateur : borne incluse (\(\leq\), \(\geq\)) ou exclue (\(<\), \(>\)).
Choisir des entrées qui font exécuter chaque bloc au moins une fois, y compris le Sinon ou l’Autrement.
Ajouter, pour chaque borne, la borne elle-même et une valeur de chaque côté.
Pour une condition composée, couvrir les lignes utiles de sa table de vérité ; vérifier qu’aucun bloc n’est inatteignable.
Tracer chaque entrée et comparer ce qu’écrit l’algorithme au résultat attendu, calculé à part.

Exercices corrigés

Les trois exercices suivants reprennent les gestes de la séance : évaluer une condition composée membre par membre, dérouler une chaîne SinonSi en comptant ses tests et en vérifiant ses bornes, repérer et corriger un mauvais ordre des tests. Chaque correction énonce la règle appliquée, donne la trace, résume les résultats dans un tableau, conclut et signale l’erreur la plus répandue.

Exercice 1 : une condition composée

Une compagnie de transport accorde un tarif réduit aux étudiants de moins de 26 ans et aux personnes d’au moins 60 ans (règle illustrative). La variable etu vaut 1 pour un étudiant, 0 sinon.

Lire age
Lire etu
Si (age < 26 ET etu = 1) OU age ≥ 60 Alors
  Écrire "réduction"
Sinon
  Écrire "plein tarif"
FinSi

Pour les entrées (age, etu) = (19, 1), (19, 0), (26, 1) et (64, 0), donner la valeur de chaque comparaison, du ET et de la condition de la ligne 3.
Qu’écrit l’algorithme pour chaque entrée ?
La ligne 3 devient Si age < 26 ET (etu = 1 OU age ≥ 60) Alors. Quelle entrée change de résultat ?
Écrire, sans NON, la condition du plein tarif, puis l’algorithme qui la teste en premier.

Correction

(a) Règle appliquée. Les comparaisons sont évaluées d’abord, puis le ET entre parenthèses, puis le OU. Le ET n’est vrai que si ses deux membres le sont ; le OU est vrai si l’un au moins de ses deux membres l’est. Pour (19, 1) : \(19<26\) vrai, \(1=1\) vrai, donc le ET est vrai, et le OU aussi, quel que soit \(19\geq60\) (faux) ; ce second membre est tout de même évalué.

(`age`, `etu`)	`age < 26`	`etu = 1`	ET	`age ≥ 60`	condition	écrit
(19, 1)	vrai	vrai	vrai	faux	vrai	`réduction`
(19, 0)	vrai	faux	faux	faux	faux	`plein tarif`
(26, 1)	faux	vrai	faux	faux	faux	`plein tarif`
(64, 0)	faux	faux	faux	vrai	vrai	`réduction`

L’entrée (26, 1) est un cas limite : « moins de 26 ans » exclut 26, et \(26<26\) est faux. La trace pour (64, 0) montre l’unique test de l’algorithme :

Pas	Ligne	Instruction	`age`	`etu`	Test	Écrit
1	1	`Lire age`	64
2	2	`Lire etu`	64	0
3	3	`Si (age < 26 ET etu = 1) OU age ≥ 60 Alors`	64	0	vrai
4	4	`Écrire “réduction”`	64	0		`réduction`

(b) L’algorithme écrit réduction pour (19, 1) et (64, 0), plein tarif pour (19, 0) et (26, 1).

(c) Règle appliquée : les parenthèses passent avant la priorité. La nouvelle condition est un ET dont le premier membre est \(\texttt{age}<26\) : elle est fausse dès que ce membre l’est. Pour (64, 0), \(64<26\) est faux ; la condition est fausse et l’algorithme écrit plein tarif :

Pas	Ligne	Instruction	`age`	`etu`	Test	Écrit
1	1	`Lire age`	64
2	2	`Lire etu`	64	0
3	3	`Si age < 26 ET (etu = 1 OU age ≥ 60) Alors`	64	0	faux
4	6	`Écrire “plein tarif”`	64	0		`plein tarif`

Pour les trois autres entrées, le résultat ne change pas : (19, 1) donne vrai ET (vrai OU faux) = vrai ; (19, 0) donne vrai ET (faux OU faux) = faux ; (26, 1) donne faux ET … = faux. Seule l’entrée (64, 0) révèle la différence : la condition modifiée retire la réduction aux personnes âgées non étudiantes.

(d) Règle appliquée : lois de De Morgan. Le plein tarif est la négation de la condition : NON ((A ET B) OU C) = NON (A ET B) ET NON C = (NON A OU NON B) ET NON C. En niant chaque comparaison (\(<\) devient \(\geq\), \(=\) devient \(\neq\), \(\geq\) devient \(<\)) :

Lire age
Lire etu
Si (age ≥ 26 OU etu ≠ 1) ET age < 60 Alors
  Écrire "plein tarif"
Sinon
  Écrire "réduction"
FinSi

Les deux blocs ont été échangés en même temps que la condition était niée : la ligne 4 écrit désormais plein tarif. Par les lois de De Morgan, la nouvelle condition est vraie exactement quand l’ancienne est fausse ; les blocs étant échangés, cette version écrit, pour toute entrée, ce qu’écrit l’algorithme de départ.

Conclusion. Une condition composée se vérifie membre par membre, sur des entrées qui parcourent les lignes utiles de sa table de vérité ; les parenthèses en changent le sens, et sa négation s’obtient par les lois de De Morgan.

Erreur fréquente

Nier la condition en gardant les connecteurs : (age ≥ 26 ET etu ≠ 1) OU age < 60. Pour (19, 1), cette condition vaut (faux ET faux) OU vrai = vrai : l’étudiant de 19 ans serait déclaré au plein tarif. Nier un ET donne un OU, nier un OU donne un ET.

Exercice 2 : une chaîne SinonSi et ses bornes

Au marché Sandaga, un commerçant accorde une remise de 5 % à partir de 10000 F d’achat et de 10 % à partir de 50000 F (règle illustrative). Dans la ligne 9, \(\times\) et div ont la même priorité et s’évaluent de gauche à droite : montant × taux est calculé avant la division par 100.

Lire montant
Si montant ≥ 50000 Alors
  taux ← 10
SinonSi montant ≥ 10000 Alors
  taux ← 5
Sinon
  taux ← 0
FinSi
remise ← montant × taux div 100
Écrire "remise :", remise
Écrire "à payer :", montant - remise

Pour les montants 9900, 10000 et 72500, donner les tests évalués, leur résultat, et la valeur de taux.
Qu’écrit l’algorithme pour chaque montant ?
Combien de tests chaque montant demande-t-il ?
On échange les conditions des lignes 2 et 4, avec leurs taux. Qu’écrit l’algorithme pour 72500 ?

Correction

(a) Règle appliquée. Les tests d’une chaîne SinonSi sont évalués dans l’ordre, jusqu’au premier vrai ; s’il n’y en a pas, le bloc Sinon est exécuté. Pour 10000, le cas limite de la borne inférieure, le premier test est faux et le second vrai :

Pas	Ligne	Instruction	`montant`	`taux`	`remise`	Test	Écrit
1	1	`Lire montant`	10000
2	2	`Si montant ≥ 50000 Alors`	10000			faux
3	4	`SinonSi montant ≥ 10000 Alors`	10000			vrai
4	5	`taux ← 5`	10000	5
5	9	`remise ← montant × taux div 100`	10000	5	500
6	10	`Écrire “remise :”, remise`	10000	5	500		`remise : 500`
7	11	`Écrire “à payer :”, montant - remise`	10000	5	500		`à payer : 9500`

Pour 72500, le premier test est vrai, et le SinonSi de la ligne 4 n’est pas évalué :

Pas	Ligne	Instruction	`montant`	`taux`	`remise`	Test	Écrit
1	1	`Lire montant`	72500
2	2	`Si montant ≥ 50000 Alors`	72500			vrai
3	3	`taux ← 10`	72500	10
4	9	`remise ← montant × taux div 100`	72500	10	7250
5	10	`Écrire “remise :”, remise`	72500	10	7250		`remise : 7250`
6	11	`Écrire “à payer :”, montant - remise`	72500	10	7250		`à payer : 65250`

Les trois montants se résument ainsi :

`montant`	test ligne 2	test ligne 4	`taux`	`remise`	à payer
9900	faux	faux	0	0	9900
10000	faux	vrai	5	500	9500
72500	vrai	(non évalué)	10	7250	65250

(b) Pour 9900 : remise : 0 et à payer : 9900 ; pour 10000 : remise : 500 et à payer : 9500, car \(10000\times5\) div \(100=500\) ; pour 72500 : remise : 7250 et à payer : 65250.

(c) Deux tests pour 9900 et pour 10000, un seul pour 72500. Le Sinon n’a pas de test : il est exécuté quand tous les tests précédents sont faux.

(d) Règle appliquée : un test n’est évalué que si les précédents sont faux. Avec les conditions échangées, le premier test devient \(\texttt{montant}\geq10000\), vrai pour 72500 :

Pas	Ligne	Instruction	`montant`	`taux`	`remise`	Test	Écrit
1	1	`Lire montant`	72500
2	2	`Si montant ≥ 10000 Alors`	72500			vrai
3	3	`taux ← 5`	72500	5
4	9	`remise ← montant × taux div 100`	72500	5	3625
5	10	`Écrire “remise :”, remise`	72500	5	3625		`remise : 3625`
6	11	`Écrire “à payer :”, montant - remise`	72500	5	3625		`à payer : 68875`

L’algorithme écrit remise : 3625 et à payer : 68875 : le client paie 3625 F de trop. Le test \(\texttt{montant}\geq50000\) de la ligne 4 n’est évalué que si \(\texttt{montant}<10000\) ; il est alors toujours faux, et la ligne 5 n’est jamais exécutée.

Conclusion. Dans une chaîne de seuils « à partir de », le seuil le plus élevé se teste en premier ; chaque seuil se vérifie sur sa valeur exacte (ici 10000 et 50000), où l’opérateur \(\geq\) décide.

Erreur fréquente

Écrire montant > 10000 pour « à partir de 10000 F » : le montant 10000 ne reçoit plus de remise. Les montants 9900 et 72500 ne détectent pas cette erreur ; seule la borne 10000 la révèle. Autre erreur répandue : croire que tous les tests d’une chaîne sont évalués, et compter deux tests pour 72500.

Exercice 3 : l’ordre des tests

L’algorithme suivant lit les longueurs \(a\), \(b\), \(c\) de trois côtés et classe le triangle. Trois longueurs forment un triangle si chacune est strictement inférieure à la somme des deux autres.

Lire a
Lire b
Lire c
Si a ≥ b + c OU b ≥ a + c OU c ≥ a + b Alors
  Écrire "pas un triangle"
SinonSi a = b OU b = c OU a = c Alors
  Écrire "isocèle"
SinonSi a = b ET b = c Alors
  Écrire "équilatéral"
Sinon
  Écrire "quelconque"
FinSi

Qu’écrit l’algorithme pour (6, 6, 6), (5, 8, 5), (3, 4, 5) et (2, 3, 5) ? Combien de tests sont évalués pour chacune ?
Quelle ligne n’est jamais exécutée, quelles que soient les entrées ? Pourquoi ?
Corriger l’algorithme.
Combien de tests demande la version corrigée pour chacune des quatre entrées ?

Correction

(a) Règle appliquée. Le premier test vrai de la chaîne choisit le bloc. Pour (6, 6, 6), le test de la ligne 4 est faux (\(6\geq12\) est faux pour chacun des trois membres) et le test de la ligne 6 est vrai, puisque \(a=b\) :

Pas	Ligne	Instruction	`a`	`b`	`c`	Test	Écrit
1	1	`Lire a`	6
2	2	`Lire b`	6	6
3	3	`Lire c`	6	6	6
4	4	`Si a ≥ b + c OU b ≥ a + c OU c ≥ a + b Alors`	6	6	6	faux
5	6	`SinonSi a = b OU b = c OU a = c Alors`	6	6	6	vrai
6	7	`Écrire “isocèle”`	6	6	6		`isocèle`

L’algorithme écrit isocèle pour un triangle équilatéral. Pour les quatre entrées :

(`a`, `b`, `c`)	écrit	tests	version corrigée	tests
(6, 6, 6)	`isocèle`	2	`équilatéral`	2
(5, 8, 5)	`isocèle`	2	`isocèle`	3
(3, 4, 5)	`quelconque`	3	`quelconque`	3
(2, 3, 5)	`pas un triangle`	1	`pas un triangle`	1

L’entrée (2, 3, 5) est un cas limite : \(5\geq2+3\) est vrai, avec l’égalité ; les trois points sont alignés, et le triangle est « aplati ». L’opérateur \(\geq\) l’écarte, comme le demande l’énoncé (« strictement inférieure »).

(b) Règle appliquée : un test hérite de ce que les précédents ont exclu. La ligne 9 n’est atteinte que si le test de la ligne 8 est vrai et celui de la ligne 6 faux. Or, si \(a=b\) ET \(b=c\) est vrai, alors \(a=b\) est vrai, donc \(a=b\) OU \(b=c\) OU \(a=c\) l’est aussi : le test de la ligne 6 a déjà choisi son bloc. La ligne 9 n’est donc jamais exécutée, et l’algorithme n’écrit jamais équilatéral, quelles que soient les entrées.

(c) Le cas le plus restrictif passe en premier : on échange les tests des lignes 6 et 8, avec leurs Écrire.

Lire a
Lire b
Lire c
Si a ≥ b + c OU b ≥ a + c OU c ≥ a + b Alors
  Écrire "pas un triangle"
SinonSi a = b ET b = c Alors
  Écrire "équilatéral"
SinonSi a = b OU b = c OU a = c Alors
  Écrire "isocèle"
Sinon
  Écrire "quelconque"
FinSi

Pas	Ligne	Instruction	`a`	`b`	`c`	Test	Écrit
1	1	`Lire a`	6
2	2	`Lire b`	6	6
3	3	`Lire c`	6	6	6
4	4	`Si a ≥ b + c OU b ≥ a + c OU c ≥ a + b Alors`	6	6	6	faux
5	6	`SinonSi a = b ET b = c Alors`	6	6	6	vrai
6	7	`Écrire “équilatéral”`	6	6	6		`équilatéral`

(d) Une entrée isocèle non équilatérale, comme (5, 8, 5), demande désormais un test de plus (3 au lieu de 2) : elle échoue d’abord sur le test « équilatéral ». Pour (3, 4, 5), les trois tests sont faux, puis le Sinon écrit quelconque :

Pas	Ligne	Instruction	`a`	`b`	`c`	Test	Écrit
1	1	`Lire a`	3
2	2	`Lire b`	3	4
3	3	`Lire c`	3	4	5
4	4	`Si a ≥ b + c OU b ≥ a + c OU c ≥ a + b Alors`	3	4	5	faux
5	6	`SinonSi a = b ET b = c Alors`	3	4	5	faux
6	8	`SinonSi a = b OU b = c OU a = c Alors`	3	4	5	faux
7	11	`Écrire “quelconque”`	3	4	5		`quelconque`

Conclusion. Quand un cas est contenu dans un autre (tout triangle équilatéral est isocèle), le cas le plus restrictif se teste en premier ; sinon, son bloc devient inatteignable.

Erreur fréquente

Vérifier l’algorithme sur (5, 8, 5) et (3, 4, 5) seulement : les deux résultats sont justes, et l’erreur passe inaperçue. Il faut une entrée par bloc, ici une entrée équilatérale. Autre erreur répandue : écrire \(a>b+c\) au lieu de \(a\geq b+c\), et déclarer triangle le cas aplati (2, 3, 5).

À retenir

Instruction	Blocs exécutés	Tests évalués	Usage
Si … FinSi	0 ou 1	1	une action dans un seul cas
Si … Sinon … FinSi	exactement 1	1	deux cas complémentaires
chaîne SinonSi	au plus 1 (1 avec Sinon)	jusqu’au premier vrai	intervalles, cas successifs
Selon … FinSelon	au plus 1 (1 avec Autrement)	jusqu’au premier Cas égal	une valeur comparée à des constantes

Une condition vaut vrai ou faux ; \(=\) compare, \(\leftarrow\) affecte.
ET est vrai si les deux membres le sont, OU si au moins un l’est ; priorités : comparaisons, NON, ET, OU ; les deux membres de ET et OU sont toujours évalués.
NON (A ET B) = NON A OU NON B ; NON (A OU B) = NON A ET NON B ; la négation de \(x>20\) est \(x\leq20\).
Dans une chaîne, un test hérite de ce que les précédents ont exclu : le cas le plus restrictif d’abord, ou les bornes dans l’ordre.
Une décision se vérifie sur une entrée par bloc, sur chaque borne et sur une valeur de chaque côté de chaque borne.

Prochaine séance

La Séance 3 introduit les boucles : TantQue, Pour et Répéter … Jusqu’à répètent un bloc tant qu’une condition, du type étudié ici, le demande ; un Si placé dans le corps d’une boucle compte, cumule ou retient une valeur à chaque tour.

Références

Cormen — Algorithms Unlocked, MIT Press, 2013 (ch. 1, « What Are Algorithms and Why Should You Care? », et ch. 2, « How to Describe and Evaluate Computer Algorithms »).
Cormen, Leiserson, Rivest, Stein — Introduction to Algorithms, 4^e éd., MIT Press, 2022 (ch. 2, « Getting Started », § 2.1 : conventions du pseudo-code, if … else).
Bhargava — Grokking Algorithms, 2^e éd., Manning, 2024 (ch. 1, « Introduction to Algorithms »).
Notes de cours en ligne : CS50 (Harvard), 6.100A (MIT), CS106A (Stanford), séances sur les conditions et les booléens.

Pour cette séance

Les slides

Slides de la séance 2

À lire en ligne

TD — Séance 2 — Les conditions

Retour au sommet