Séance 2 — Les conditions

Décider, combiner, choisir entre plusieurs cas

Dr. El Hadji Bassirou TOURÉ

Département de Mathématiques et Informatique, Faculté des Sciences et Techniques, Université Cheikh Anta Diop de Dakar

Objectifs de la séance

Ce que la séance construit

La condition, qui fait dépendre des données la suite de l’exécution : le Si à un cas et à deux cas (Sinon), les conditions composées par ET, OU, NON et leurs tables de vérité, le choix entre plusieurs cas par des Si imbriqués, par une chaîne SinonSi ou par Selon, et les erreurs qui se cachent aux bornes. Chaque algorithme est suivi pas à pas : la ligne exécutée, l’état des variables, le test évalué, ce qu’écrit Écrire.

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

Navigation conceptuelle

D’où l’on vient, où l’on va

Amont. Variables et types (entier, réel, booléen, caractère, chaîne), affectation \(\leftarrow\), Lire, Écrire et trace d’exécution (Séance 1). Jusqu’ici, toutes les lignes s’exécutent, 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 ; 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.

Les conventions du pseudo-code

écriture	sens
\(x\leftarrow e\) ; Lire `n` ; Écrire `"prix :"`, `p`	affectation ; lecture au clavier ; écriture, puis à la ligne (Séance 1)
\(+\ -\ \times\ /\) ; div, mod	opérations ; quotient et reste de la division entière (\(7\) mod \(2=1\))
réel ; booléen écrit	virgule et au moins une décimale : `13,5`, `12,0` ; Écrire écrit `vrai` ou `faux`
\(=\ \neq\ <\ \leq\ >\ \geq\)	comparaison : résultat vrai ou faux, une valeur booléenne
`b` \(\leftarrow\) `a mod 4 = 0`	une variable booléenne reçoit le résultat d’une comparaison
caractère, chaîne	\(=\) et \(\neq\) seulement : `rep = "oui"` ; jamais \(<\) entre chaînes
NON \(C\) ; \(C_1\) ET \(C_2\) ; \(C_1\) OU \(C_2\)	connecteurs ; 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
\(0\leq x\leq20\)	s’écrit `x` \(\geq\) `0` ET `x` \(\leq\) `20`
erreur : arrêt de l’exécution	division par zéro, `n mod 0` compris

Dans les traces, la colonne test donne le résultat de la condition évaluée au pas.

Les conventions du pseudo-code : les instructions

écriture	sens
Si \(C\) Alors \(B\) FinSi	\(B\) exécuté si \(C\) est vraie ; au plus une fois
Si \(C\) Alors \(B_1\) Sinon \(B_2\) FinSi	\(B_1\) si \(C\) est vraie, \(B_2\) sinon : un et un seul des deux
Si \(C_1\) Alors … SinonSi \(C_2\) Alors … Sinon … FinSi	tests dans l’ordre ; le premier vrai choisit son bloc ; un seul FinSi
Selon \(e\) Faire / Cas \(v\) : … / Autrement : … / FinSelon	\(e\) évaluée une fois, comparée aux Cas dans l’ordre ; Autrement si aucun
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
pas de la trace	la ligne Selon produit un pas (valeur examinée) ; Sinon, Autrement, FinSi, FinSelon n’en produisent pas
retrait de 2 espaces, mot de fin	délimitent les blocs d’un Si ou d’un Selon

\(=\) n’est pas \(\leftarrow\)

x = 5 est un test, qui vaut vrai ou faux et ne modifie rien ; x \(\leftarrow\) 5 est une affectation, qui donne la valeur 5 à x. Une condition s’écrit avec \(=\), jamais avec \(\leftarrow\).

L’instruction Si … Alors … FinSi

En Séance 1, toutes les lignes s’exécutent ; une condition en fait sauter certaines.

{Si \(C\) Alors \(B\) FinSi}

Évaluer la condition \(C\) ; si elle est vraie, exécuter le bloc \(B\), puis passer à la suite ; si elle est fausse, sauter \(B\) et passer directement à la ligne qui suit FinSi.

Lecture. Livraison à 1000 F, offerte dès 20000 F d’achat (règle illustrative) : la valeur par défaut précède le Si, qui ne la change que dans un cas.

La décision à un cas, pas à pas

Entrée au clavier : 25000

Écrit par Écrire \(\rightarrow\)

à payer : 25000

Lecture. Ligne 1 : Lire montant ; l’entrée au clavier donne montant \(=\) 25000.

Lecture. Ligne 2 : frais reçoit 1000.

Lecture. Ligne 3 : test du Si, montant ≥ 20000, soit 25000 ≥ 20000 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 4 : frais ← 0 : frais passe de 1000 à 0.

Lecture. Ligne 6 : Écrire écrit « à payer : 25000 » ; l’algorithme est terminé. Le test vrai a fait exécuter la ligne 4 ; avec 15000, il serait faux et la ligne 4 serait sautée.

L’instruction Si … Alors … Sinon … FinSi

{Si \(C\) Alors \(B_1\) Sinon \(B_2\) FinSi}

Évaluer \(C\) ; si elle est vraie, exécuter \(B_1\) ; sinon, exécuter \(B_2\) ; puis passer à la ligne qui suit FinSi. À chaque exécution, un et un seul des deux blocs est exécuté.

Lecture. Un entier est pair quand le reste de sa division par 2 est nul : n mod 2 = 0. La condition est une comparaison, de valeur vrai ou faux.

La décision à deux cas, pas à pas

Entrée au clavier : 7

Écrit par Écrire \(\rightarrow\)

7 est impair
fin

Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 7.

Lecture. Ligne 2 : test du Si, n mod 2 = 0, soit 7 mod 2 = 0 : faux ; le bloc Sinon est exécuté.

Lecture. Ligne 5 : Écrire écrit « 7 est impair » ; suite à la ligne 7.

Lecture. Ligne 7 : Écrire écrit « fin » ; l’algorithme est terminé. Un seul des deux blocs a été exécuté : la ligne 3 n’est jamais atteinte pour 7.

ET, OU, NON : les tables de vérité

Une condition peut combiner plusieurs comparaisons ; sa valeur se calcule par les tables 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

ET est vrai si les deux membres le sont ; OU est vrai si au moins un l’est (les deux compris) ; NON inverse.

Priorités et parenthèses

Les comparaisons sont évaluées d’abord, puis NON, puis ET, puis OU : a < 26 ET e = 1 OU a ≥ 60 se lit (a < 26 ET e = 1) OU a ≥ 60. Les parenthèses changent l’ordre et, au moindre doute, s’écrivent.

Lecture. NON (x \(\geq\) 0 ET x \(\leq\) 20) vaut x \(<\) 0 OU x \(>\) 20 : nier un ET donne un OU des négations (lois de De Morgan).

Une condition composée, pas à pas : l’année bissextile

Entrée au clavier : 1900

Écrit par Écrire \(\rightarrow\)

1900 non bissextile

Lecture. Ligne 1 : Lire a ; l’entrée au clavier donne a \(=\) 1900.

Lecture. Ligne 2 : p reçoit a mod 4 = 0 ET a mod 100 ≠ 0, soit vrai ET faux : faux.

Lecture. Ligne 3 : b reçoit p OU a mod 400 = 0, soit faux OU faux : faux.

Lecture. Ligne 4 : test du Si : b vaut faux ; le bloc Sinon est exécuté.

Lecture. Ligne 7 : Écrire écrit « 1900 non bissextile » ; l’algorithme est terminé. 1900 est multiple de 4, mais aussi de 100 sans l’être de 400 : il n’est pas bissextile.

L’évaluation des deux membres

Entrée au clavier : 12 ; 0

Écrit par Écrire \(\rightarrow\)

arrêt : division par zéro

Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 12.

Lecture. Ligne 2 : Lire d ; l’entrée au clavier donne d \(=\) 0.

Lecture. Ligne 3 : ET évalue ses deux membres : d ≠ 0 donne faux, puis n mod d = 0 demande 12 mod 0 = 0, une division par zéro : arrêt de l’exécution. Le premier membre faux ne protège pas le second.

Quoi, pourquoi, quand ça échoue : ET, OU, NON

Quoi

Une année est bissextile si elle est multiple de 4 sans l’être de 100, ou si elle est multiple de 400 : deux comparaisons reliées par ET, puis un OU. Chaque comparaison vaut vrai ou faux ; le connecteur combine ces deux valeurs.

Pourquoi les tables de vérité

Elles donnent la valeur de la condition pour toutes les combinaisons : 4 lignes pour deux comparaisons, 8 pour trois. Une condition composée se vérifie sur chaque ligne utile, et non sur un seul exemple.

Quand ça échoue

d \(\neq\) 0 ET n mod d = 0 : les deux membres sont évalués, la division par zéro arrête l’exécution ; il faut un Si imbriqué. note \(\geq\) 0 OU note \(\leq\) 20 : toujours vraie (section 4) ; un intervalle s’écrit avec ET.

Exercice : une condition composée

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

Tarif réduit (règle illustrative)

Pour (19, 1), (19, 0), (26, 1), (64, 0) : 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 age < 26 ET (etu = 1 OU age ≥ 60). Quelle entrée change de résultat ?
Écrire la condition du plein tarif sans NON.

Correction

(`age`, `etu`)	\(<26\)	\(=1\)	ET	\(\geq60\)	cond.	é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

ET n’est vrai que pour (19, 1) ; OU ajoute (64, 0), grâce à \(64\geq60\).
Réduction pour (19, 1) et (64, 0) ; plein tarif pour les deux autres.
(64, 0) : \(64<26\) est faux, donc le ET est faux : plein tarif. Les parenthèses ont changé le sens.
NON ((A ET B) OU C) \(=\) (NON A OU NON B) ET NON C : (age ≥ 26 OU etu ≠ 1) ET age < 60.

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

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

Le bloc d’un Si est une suite d’instructions quelconque ; il peut contenir un autre Si. Au baccalauréat sénégalais, le candidat est admis au premier groupe avec une moyenne \(m\) d’au moins 10 sur 20 ; mention 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).

Si imbriqués

Un Si placé dans le bloc Sinon d’un autre n’est évalué que si la condition de celui-ci est fausse : à la ligne 5, on sait déjà que \(m\geq10\).

Lecture. Quatre tests pour cinq cas ; chaque niveau ajoute un retrait et un FinSi.

La chaîne SinonSi

{Si \(C_1\) Alors \(B_1\) SinonSi \(C_2\) Alors \(B_2\) … Sinon \(B\) FinSi}

Les conditions sont testées dans l’ordre ; la première vraie fait exécuter son bloc, et les suivantes ne sont pas évaluées ; si aucune n’est vraie, le bloc Sinon (facultatif) est exécuté. SinonSi \(C_2\) Alors s’écrit à la place de Sinon / Si \(C_2\) Alors, avec un seul FinSi.

Lecture. Mêmes tests, même ordre, mêmes résultats que les Si imbriqués ; le texte reste aligné.

La chaîne SinonSi, pas à pas

Entrée au clavier : 13,5

Écrit par Écrire \(\rightarrow\)

Assez bien

Lecture. Ligne 1 : Lire m ; l’entrée au clavier donne m \(=\) 13,5.

Lecture. Ligne 2 : test du Si, m < 10, soit 13,5 < 10 : faux ; passage au SinonSi de la ligne 4.

Lecture. Ligne 4 : test du SinonSi, m < 12, soit 13,5 < 12 : faux ; passage au SinonSi de la ligne 6.

Lecture. Ligne 6 : test du SinonSi, m < 14, soit 13,5 < 14 : vrai ; son bloc est exécuté, les tests suivants ne sont pas évalués.

Lecture. Ligne 7 : Écrire écrit « Assez bien » ; l’algorithme est terminé. Trois tests évalués sur quatre : le premier vrai arrête la chaîne.

Selon … Cas … Autrement : le prix du TER

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

Prix selon le nombre de zones traversées, 1, 2 ou 3 (tarifs illustratifs). Selon compare une même valeur à des constantes : c’est une chaîne SinonSi dont chaque test est z = v ; Autrement joue le rôle de Sinon.

Lecture. Les deux écritures font les mêmes comparaisons, dans le même ordre : pour \(z=4\), trois comparaisons, puis Autrement et prix : 0. Cas \(v_1\), \(v_2\) : équivaut à \(z=v_1\) OU \(z=v_2\) ; comme pour tout OU, toutes les comparaisons du Cas sont évaluées.

Selon, pas à pas

Entrée au clavier : 2

Écrit par Écrire \(\rightarrow\)

prix : 1000

Lecture. Ligne 1 : Lire z ; l’entrée au clavier donne z \(=\) 2.

Lecture. Ligne 2 : Selon évalue z une fois, soit 2 ; puis comparaison avec chaque Cas, dans l’ordre.

Lecture. Ligne 3 : Cas 1 : compare z = 1, soit 2 = 1 : faux ; Cas suivant.

Lecture. Ligne 5 : Cas 2 : compare z = 2, soit 2 = 2 : vrai ; son bloc est exécuté, les Cas suivants ne sont pas comparés.

Lecture. Ligne 6 : prix reçoit 1000.

Lecture. Ligne 12 : Écrire écrit « prix : 1000 » ; l’algorithme est terminé. z a été comparé à 1, puis à 2 ; le Cas 3 n’a pas été examiné.

Exercice : une chaîne SinonSi

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

Remise (règle illustrative)

5 % à partir de 10000 F d’achat, 10 % à partir de 50000 F ; × et div : de gauche à droite.

Pour 9900, 10000 et 72500 : tests évalués, résultats, 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 ?

Exercice : une chaîne SinonSi, correction

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

Correction

montant	tests (l. 2, l. 4)	`taux`	`remise`	à payer
9900	faux, faux	0	0	9900
10000	faux, vrai	5	500	9500
72500	vrai	10	7250	65250

Le premier test vrai fixe taux ; 10000 vérifie \(\geq\) 10000 : la borne est incluse.
remise \(=\) montant \(\times\) taux div 100 : 0, 500, 7250.
2 tests pour 9900 et 10000, 1 seul pour 72500.
72500 \(\geq\) 10000 est vrai dès le premier test : taux \(=5\), remise : 3625, à payer : 68875 ; la ligne du taux 10 n’est jamais atteinte.

Les bornes incluses ou exclues

Une condition partage les valeurs en deux ; l’erreur se loge à la frontière, sur la borne elle-même.

La chaîne SinonSi de la mention écrit m < 12 ; avec m ≤ 12 (et de même pour 14 et 16), elle se trompe exactement sur les bornes :

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

Lecture. Une condition se vérifie sur chaque borne et sur une valeur de chaque côté : 11,5, 12 et 13 pour la borne 12.

L’ordre des tests, pas à pas

Entrée au clavier : 17,0

Écrit par Écrire \(\rightarrow\)

Passable

Lecture. Ligne 1 : Lire m ; l’entrée au clavier donne m \(=\) 17,0.

Lecture. Ligne 2 : test du Si, m ≥ 10, soit 17,0 ≥ 10 : vrai ; son bloc est exécuté, les tests suivants ne sont pas évalués.

Lecture. Ligne 3 : Écrire écrit « Passable » ; l’algorithme est terminé. La moyenne 17 mérite « Très bien » : le premier test, trop large, capte toutes les moyennes d’au moins 10.

Une condition toujours vraie, pas à pas

Entrée au clavier : 25

Écrit par Écrire \(\rightarrow\)

note valide : 25

Lecture. Ligne 1 : Lire note ; l’entrée au clavier donne note \(=\) 25.

Lecture. Ligne 2 : test du Si, note ≥ 0 OU note ≤ 20, soit vrai OU faux : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 3 : Écrire écrit « note valide : 25 » ; l’algorithme est terminé. Toute valeur vérifie l’un des deux membres : la condition est toujours vraie.

Quoi, pourquoi, quand ça échoue : erreurs de condition

Quoi

Trois erreurs qui ne provoquent aucun arrêt : une borne mal placée (\(\leq\) au lieu de \(<\)), un mauvais ordre des tests (m ≥ 10 avant m ≥ 16), une condition toujours vraie (OU au lieu de ET).

Pourquoi l’ordre compte

Dans une chaîne SinonSi, un test n’est évalué que si tous les précédents sont faux : le plus restrictif passe d’abord, ou bien les tests s’enchaînent dans l’ordre des bornes (\(m<10\), \(m<12\), …).

Quand ça échoue

Si x \(\leftarrow\) 5 Alors : une affectation à la place d’un test, ligne sans sens. x = x + 1 seule n’est pas une instruction du pseudo-code : une comparaison seule ne modifie aucune variable. Une trace sur une seule valeur ne détecte aucune de ces erreurs : il faut chaque bloc et chaque borne.

Exercice : l’ordre des tests

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

Classer un triangle

Trois longueurs forment un triangle si chacune est strictement inférieure à la somme des deux autres.

Écrit et nombre de tests pour (6, 6, 6), (5, 8, 5), (3, 4, 5), (2, 3, 5) ?
Quelle ligne n’est jamais exécutée ? Pourquoi ?
Corriger l’algorithme.
Nombre de tests de la version corrigée ?

Exercice : l’ordre des tests, correction

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

Correction

(`a`, `b`, `c`)	écrit	tests	corrigé	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

(6, 6, 6) est déclaré « isocèle » ; (2, 3, 5) : \(5\geq2+3\), triangle aplati, borne incluse.
La ligne 9 : si \(a=b\) ET \(b=c\) est vrai, \(a=b\) OU … l’est aussi, et le test de la ligne 6 a déjà choisi.
Échanger les tests des lignes 6 et 8 (et leurs Écrire) : le cas le plus restrictif d’abord.
(5, 8, 5) passe de 2 à 3 tests : il échoue désormais sur le test « équilatéral ».

À retenir

instruction	blocs exécutés	tests évalués	usage
Si … FinSi	0 ou 1	1	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 successifs
Selon … FinSelon	au plus 1 (1 avec Autrement)	jusqu’au premier Cas égal	une valeur comparée à des constantes

À retenir

ET : vrai si les deux membres le sont ; OU : si au moins un l’est ; priorités : comparaisons, puis NON, ET, OU ; les deux membres sont toujours évalués.
NON (A ET B) \(=\) NON A OU NON B ; NON (A OU B) \(=\) NON A ET NON B.
Vérifier une condition sur chaque bloc, chaque borne, et une valeur de chaque côté de chaque borne.
Dans une chaîne, le test le plus restrictif d’abord ; \(=\) teste, \(\leftarrow\) affecte.

Prochaine séance

Séance 3 — Les boucles

Une boucle répète un bloc tant qu’une condition le demande : TantQue teste sa condition avant chaque tour, Répéter … Jusqu’à après ; Pour fait varier un compteur entre deux bornes. Un Si placé dans le corps compte, cumule ou retient une valeur à chaque tour.

À préparer : écrire la condition « n est multiple de 3 », puis l’appliquer à la main à chaque entier de 1 à 20 en comptant les multiples ; relever ce qui se répète d’un entier au suivant.

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 » : conditions en pseudo-code).
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.