Logique de programmation : conditions et décisions (si, sinon, cas multiples)

Prendre des décisions avec des conditions

Une condition est une expression qui produit un booléen : vrai ou faux. Elle permet de choisir un chemin d’exécution : si la condition est vraie, on exécute un bloc, sinon on exécute un autre bloc (ou rien). L’objectif est double : (1) exprimer correctement la règle métier, (2) couvrir tous les cas, notamment les cas frontières (valeurs exactement sur une borne).

Booléens et comparaisons

Les comparaisons les plus courantes :

• a == b : égalité
• a != b : différence
• a < b, a <= b, a > b, a >= b : ordre

Exemple : age >= 18 produit vrai si l’âge est au moins 18.

Conjonction, disjonction et négation

• ET (souvent &&) : toutes les conditions doivent être vraies
• OU (souvent ||) : au moins une condition doit être vraie
• NON (souvent !) : inverse un booléen

Exemples :

• age >= 18 && statut == "etudiant"
• zone == "A" || zone == "B"
• !(poids > 20) équivaut à poids <= 20

Priorité des opérateurs (et parenthèses)

Sans parenthèses, les opérateurs ne s’évaluent pas tous au même “niveau”. En pratique, pour éviter les erreurs, mettez des parenthèses dès qu’une expression mélange ET et OU.

Continuez dans notre application.

Vous pouvez écouter le livre audio écran éteint, recevoir un certificat gratuit pour ce cours et accéder également à 5 000 autres cours en ligne gratuits.

Ou poursuivez votre lecture ci-dessous...

Téléchargez l'application

Exemple ambigu :

eligible = statut == "etudiant" || statut == "senior" && age >= 65

Selon la priorité, cela peut être interprété comme :

eligible = (statut == "etudiant") || ((statut == "senior") && (age >= 65))

Si l’intention est “(étudiant OU senior) ET âge >= 65”, il faut écrire :

eligible = (statut == "etudiant" || statut == "senior") && age >= 65

Si / sinon / cas multiples

Trois formes fréquentes :

• Si simple : un seul cas déclenche une action.
• Si / sinon : deux chemins exclusifs.
• Sinon si (chaîne) ou cas multiples : plusieurs catégories, une seule doit s’appliquer.

Règle pratique : dans une chaîne de sinon si, l’ordre des tests est crucial. On place en général les cas les plus spécifiques en premier, et on termine par un sinon “par défaut” si possible.

Arbres de décision : rendre l’ordre des tests explicite

Un arbre de décision consiste à poser des questions binaires (oui/non) qui mènent à une décision finale. Pour le construire :

• Listez les critères (ex : âge, statut, plafond).
• Repérez les cas impossibles ou prioritaires (ex : données invalides).
• Choisissez un ordre de questions qui élimine rapidement des branches.
• Vérifiez que chaque combinaison plausible aboutit à une feuille (décision).

Clauses de garde (early return) : simplifier les conditions

Une clause de garde consiste à traiter immédiatement un cas “bloquant” (souvent invalide) et à sortir tôt, au lieu d’imbriquer de nombreux si.

Exemple (pseudo-code) :

fonction prixLivraison(zone, poids):    si poids < 0:        retourner erreur    si zone non reconnue:        retourner erreur    ... calcul normal ...

Avantage : le “chemin nominal” reste lisible, et les cas particuliers sont isolés.

Gestion des intervalles (bornes incluses/excluses)

Beaucoup de décisions reposent sur des intervalles : [a, b] (bornes incluses) ou (a, b], etc. Deux règles pratiques :

• Décidez explicitement si chaque borne est incluse (<=, >=) ou exclue (<, >).
• Évitez les “trous” et les chevauchements : chaque valeur doit appartenir à exactement une catégorie.

Technique simple : utilisez des intervalles contigus avec des comparaisons cohérentes, par exemple : si x < 0, sinon si x < 10, sinon… (ici, les bornes sont implicites et sans chevauchement).

Exercices guidés (problèmes 5 à 8)

Pour chaque exercice : (1) on clarifie les règles, (2) on fixe l’ordre des tests, (3) on liste les cas frontières, (4) on propose un jeu de tests minimal.

Exercice 5 — Éligibilité à une réduction (âge, statut, plafond)

Énoncé : Une réduction est accordée si la personne est (étudiante OU senior) ET respecte un plafond de revenu. Règles :

• Statut possible : "etudiant", "senior", "autre".
• Senior : âge >= 65.
• Étudiant : statut "etudiant" (l’âge n’est pas un critère).
• Plafond : revenu annuel <= 20000.
• Si les données sont invalides (âge < 0, revenu < 0), renvoyer "invalide".

Étapes :

• 1) Clauses de garde : vérifier âge et revenu.
• 2) Calculer estSenior et estEtudiant.
• 3) Vérifier le plafond.
• 4) Décider : (estEtudiant OU estSenior) ET sousPlafond.

Ordre des tests (important) :

• Test 1 : invalidité (early return).
• Test 2 : sous plafond (peut éliminer tôt).
• Test 3 : statut/âge (éligibilité “profil”).

fonction eligibiliteReduction(age, statut, revenu):    si age < 0 ou revenu < 0:        retourner "invalide"    sousPlafond = (revenu <= 20000)    si !sousPlafond:        retourner "non"    estEtudiant = (statut == "etudiant")    estSenior = (age >= 65)    si estEtudiant || estSenior:        retourner "oui"    sinon:        retourner "non"

Cas frontières :

• Revenu exactement à 20000 (inclus).
• Âge exactement à 65 (senior inclus).
• Âge négatif / revenu négatif (invalide).

Jeu de tests minimal :

Exercice 6 — Frais de livraison selon zone et poids

Énoncé : Calculer les frais selon la zone (A, B, C) et le poids (kg). Règles :

• Si poids <= 0 : "invalide".
• Zone A : jusqu’à 5 kg inclus = 5€, au-delà = 8€.
• Zone B : jusqu’à 5 kg inclus = 7€, au-delà = 10€.
• Zone C : jusqu’à 5 kg inclus = 9€, au-delà = 14€.
• Zone inconnue : "invalide".

Étapes :

• 1) Clause de garde : poids valide.
• 2) Clause de garde : zone reconnue.
• 3) Déterminer la tranche de poids (≤ 5 ou > 5).
• 4) Appliquer le tarif de la zone.

Ordre des tests :

• Test 1 : poids (évite tout calcul inutile).
• Test 2 : zone (évite un cas incomplet).
• Test 3 : tranche de poids, puis tarif par zone.

fonction fraisLivraison(zone, poids):    si poids <= 0:        retourner "invalide"    si zone != "A" et zone != "B" et zone != "C":        retourner "invalide"    leger = (poids <= 5)    si zone == "A":        retourner (5 si leger sinon 8)    sinon si zone == "B":        retourner (7 si leger sinon 10)    sinon: // zone == "C"        retourner (9 si leger sinon 14)

Cas frontières :

• Poids = 5 (borne incluse dans “léger”).
• Poids = 0 (invalide).
• Zone inconnue.

Jeu de tests minimal :

Exercice 7 — Noter une performance (barème à seuils)

Énoncé : Attribuer une note (A, B, C, D, E) à partir d’un score sur 100. Règles :

• Score invalide si < 0 ou > 100.
• A : score ≥ 90
• B : 80 ≤ score < 90
• C : 70 ≤ score < 80
• D : 60 ≤ score < 70
• E : score < 60

Étapes :

• 1) Clause de garde : score dans [0, 100].
• 2) Tester les seuils du plus élevé au plus bas.
• 3) Retourner la première catégorie qui correspond.

Ordre des tests : du plus grand seuil au plus petit, sinon un score de 95 satisferait aussi “≥ 60” si on testait dans l’autre sens.

fonction noter(score):    si score < 0 ou score > 100:        retourner "invalide"    si score >= 90:        retourner "A"    sinon si score >= 80:        retourner "B"    sinon si score >= 70:        retourner "C"    sinon si score >= 60:        retourner "D"    sinon:        retourner "E"

Cas frontières :

• 0 et 100 (bornes valides).
• 59/60, 69/70, 79/80, 89/90 (changements de classe).
• -1 et 101 (invalides).

Jeu de tests minimal :

Exercice 8 — Classifier une température (gel/froid/tiède/chaud) avec bornes incluses/excluses

Énoncé : Classer une température en °C selon ces intervalles (attention aux bornes) :

• gel : T ≤ 0 (0 inclus)
• froid : 0 < T ≤ 10 (0 exclu, 10 inclus)
• tiède : 10 < T < 25 (10 exclu, 25 exclu)
• chaud : T ≥ 25 (25 inclus)

Étapes :

• 1) (Optionnel) Clause de garde si vous imposez une plage réaliste (ex : T < -100 ou T > 100 → invalide). Si aucune contrainte, passer.
• 2) Tester les intervalles dans un ordre qui évite chevauchement : du plus bas vers le plus haut avec des comparaisons strictes/inclusives cohérentes.
• 3) Vérifier explicitement les bornes 0, 10, 25.

Ordre des tests : commencer par T <= 0, puis T <= 10, puis T < 25, sinon chaud. Cet ordre garantit qu’une valeur tombe dans une seule catégorie.

fonction classifierTemperature(T):    si T <= 0:        retourner "gel"    sinon si T <= 10:        retourner "froid"    sinon si T < 25:        retourner "tiede"    sinon:        retourner "chaud"

Cas frontières :

• T = 0 → gel (0 inclus dans gel, exclu de froid).
• T = 10 → froid (10 inclus dans froid, exclu de tiède).
• T = 25 → chaud (25 exclu de tiède, inclus dans chaud).
• Valeurs juste autour : -0.1, 0.1, 9.9, 10.1, 24.9, 25.0.

Jeu de tests minimal :