Imbrication de conditions pour cas multiples

Introduction

Dans la leçon précédente, nous avons introduit la structure Si...Alors...Sinon, un outil puissant pour permettre à un algorithme de faire un choix entre deux options. Vous avez appris à évaluer une condition et à exécuter un bloc d'instructions si elle est vraie, ou un autre bloc si elle est fausse.

Cependant, de nombreux problèmes réels exigent de choisir non pas entre deux, mais entre trois, quatre, ou même plus de possibilités. Par exemple :

• Un feu de signalisation peut être rouge, orange ou vert.
• Une note d'examen peut donner lieu à plusieurs mentions : "Très bien", "Bien", "Passable", ou "Insuffisant".

L'objectif de cette leçon est d'apprendre à gérer ces cas multiples de manière propre et efficace. Pour cela, nous allons imbriquer les structures conditionnelles pour créer une chaîne de décisions, ce qui se traduit par la structure Si...SinonSi...Sinon. Maîtriser cette technique est essentiel pour modéliser des logiques complexes et progresser vers votre objectif d'écrire un "code clean".

1. Le défi des cas multiples

Imaginons que nous voulions écrire un algorithme qui détermine si un nombre entier est positif, négatif ou nul. Avec ce que nous savons jusqu'à présent (la structure Si...Alors...Sinon simple), nous pourrions être tenté(e) d'écrire ceci :

// Approche avec plusieurs "Si" séparés (non optimale)
Algorithme Signe_Inefficace
  Variable
    N : Entier
  Début
    Ecrire("Entrez un nombre :")
    Lire(N)

    Si (N > 0) Alors
      Ecrire("Le nombre est positif.")
    FinSi

    Si (N < 0) Alors
      Ecrire("Le nombre est négatif.")
    FinSi

    Si (N == 0) Alors
      Ecrire("Le nombre est nul.")
    FinSi
  Fin

Cet algorithme fonctionne, mais il n'est pas efficace. Si vous entrez 10, la première condition (N > 0) est vraie, et le message "Le nombre est positif." s'affiche. Cependant, l'algorithme va quand même tester les deux autres conditions (N < 0 et N == 0), même si nous savons déjà qu'elles seront fausses. C'est un travail inutile.

La solution est de lier ces conditions entre elles pour que l'algorithme s'arrête dès qu'il a trouvé le bon cas.

2. La structure Si...SinonSi...Sinon

Pour créer une chaîne de décision, on "imbrique" les structures conditionnelles. Cela signifie que l'on place une nouvelle structure Si à l'intérieur du bloc Sinon de la précédente.

La syntaxe de base est la suivante :

Si <condition 1> Alors
    // Bloc d'instructions 1
Sinon
    Si <condition 2> Alors
        // Bloc d'instructions 2
    Sinon
        // Bloc d'instructions 3 (par défaut)
    FinSi
FinSi

Pour rendre cela plus lisible, les langages algorithmiques proposent une syntaxe condensée : SinonSi.

Si <condition 1> Alors
    // Bloc 1 : exécuté si la condition 1 est VRAIE.
    // L'algorithme saute ensuite à la fin (après FinSi).
SinonSi <condition 2> Alors
    // Bloc 2 : exécuté si la condition 1 est FAUSSE ET la condition 2 est VRAIE.
Sinon
    // Bloc 3 : exécuté si TOUTES les conditions précédentes sont FAUSSES.
FinSi

L'avantage fondamental est que l'évaluation s'arrête dès qu'une condition est vraie. C'est plus logique et plus performant.

Pour visualiser ce flux de décision, je vous invite à consulter la ressource suivante qui utilise l'exemple du signe d'un nombre (positif, négatif, nul).

Comme vous l'avez vu, la version optimisée de notre algorithme Signe est bien plus élégante :

Algorithme Signe_Efficace
  Variable
    N : Entier
  Début
    Ecrire("Entrez un nombre :")
    Lire(N)

    Si (N > 0) Alors
      Ecrire("Le nombre est positif.")
    SinonSi (N < 0) Alors
      Ecrire("Le nombre est négatif.")
    Sinon
      Ecrire("Le nombre est nul.")
    FinSi
  Fin

Analyse de l'exécution :

• Si l'utilisateur saisit 10 : La condition N > 0 est VRAI. Le message s'affiche, et l'algorithme saute directement après le FinSi, sans tester les autres cas.
• Si l'utilisateur saisit -5 : La condition N > 0 est FAUX. L'algorithme passe au SinonSi. La condition N < 0 est VRAI. Le message s'affiche, et c'est terminé.
• Si l'utilisateur saisit 0 : La condition N > 0 est FAUX. La condition N < 0 est FAUX. L'algorithme exécute donc le bloc Sinon par défaut.

3. Mise en pratique : attribution d'une mention

Appliquons cette logique à un cas pratique un peu plus complexe : attribuer une mention en fonction d'une moyenne.

Problème : Écrire un algorithme qui demande une moyenne (sur 20) et affiche la mention correspondante :

• "Admis avec mention" si moyenne $\ge$ 12
• "Admis sans mention" si 10 $\le$ moyenne < 12
• "Recalé" si moyenne < 10

Voici l'algorithme qui résout ce problème. Faites bien attention à l'ordre des conditions ! On commence par le cas le plus restrictif (la note la plus haute).

Algorithme Mentions
  Variable
    moyenne : Réel
  Début
    Ecrire("Entrez la moyenne du candidat :")
    Lire(moyenne)

    Si (moyenne >= 12) Alors
      Ecrire("Admis avec mention.")
    SinonSi (moyenne >= 10) Alors
      // On arrive ici seulement si moyenne < 12
      Ecrire("Admis sans mention.")
    Sinon
      // On arrive ici seulement si moyenne < 10
      Ecrire("Recalé.")
    FinSi
  Fin

Notez qu'il n'est pas nécessaire d'écrire SinonSi (moyenne >= 10 ET moyenne < 12). Le fait d'être dans le SinonSi garantit déjà que la première condition (moyenne >= 12) était fausse. C'est ce qui rend ce code "clean" et facile à lire.

4. À vous de jouer !

Comme vous préférez la pratique, voici deux exercices pour vous entraîner. Prenez une feuille et un crayon, et essayez de les résoudre en utilisant la structure Si...SinonSi...Sinon.

Exercice 1 : Indice de Masse Corporelle (IMC)

L'OMS classe les individus en trois catégories selon leur IMC :

• IMC < 18.5 : Maigreur
• 18.5 <= IMC < 25 : Corpulence normale
• IMC >= 25 : Surpoids

Concevez un algorithme qui demande le poids (en kg) et la taille (en m) d'une personne, calcule son IMC avec la formule $\text{IMC}=\frac{\text{poids}}{{\text{taille}}^2}$, puis affiche la catégorie correspondante ("Maigreur", "Corpulence normale" ou "Surpoids").

Algorithme ClassificationIMC
  Variables
    poids : Réel
    taille : Réel
    imc : Réel
  Début
    Ecrire("Entrez votre poids en kg :")
    Lire(poids)
    Ecrire("Entrez votre taille en mètres :")
    Lire(taille)

    // Calcul de l'IMC
    imc <-- poids / (taille * taille)

    Ecrire("Votre IMC est de ", imc)

    // Classification
    Si (imc >= 25) Alors
      Ecrire("Catégorie : Surpoids")
    SinonSi (imc >= 18.5) Alors
      Ecrire("Catégorie : Corpulence normale")
    Sinon
      Ecrire("Catégorie : Maigreur")
    FinSi
  Fin

Exercice 2 : Tarif de cinéma

Un cinéma propose les tarifs suivants en fonction de l'âge :

• Moins de 13 ans : Tarif enfant (6€)
• De 13 à 64 ans : Plein tarif (10€)
• 65 ans et plus : Tarif senior (8€)

Écrivez un algorithme qui demande l'âge du spectateur et affiche le prix du billet.

Algorithme TarifCinema
  Variable
    age : Entier
    prix : Entier
  Début
    Ecrire("Quel est l'âge du spectateur ?")
    Lire(age)

    Si (age < 13) Alors
      prix <-- 6  // Tarif enfant
    SinonSi (age < 65) Alors
      // On arrive ici si age >= 13
      prix <-- 10 // Plein tarif
    Sinon
      // On arrive ici si age >= 65
      prix <-- 8  // Tarif senior
    FinSi

    Ecrire("Le prix du billet est de ", prix, "€.")
  Fin

Conclusion

Vous venez d'ajouter un outil très puissant à votre boîte à outils d'algorithmicien. Vous savez maintenant comment gérer des situations avec de multiples issues possibles de manière structurée et efficace.

Points clés à retenir :

• Pour gérer plus de deux cas mutuellement exclusifs, on utilise la structure Si...SinonSi...Sinon.
• Cette structure est une chaîne de décisions : l'évaluation s'arrête dès qu'une condition est trouvée vraie.
• C'est une méthode plus performante et plus lisible que l'utilisation de plusieurs structures Si indépendantes.
• Le bloc Sinon final est optionnel mais très utile pour gérer le cas par défaut, lorsque toutes les autres conditions sont fausses.

Et après ?

Jusqu'à présent, chaque test portait sur une seule condition (age < 13, imc >= 25). Mais que faire si une décision dépend de plusieurs facteurs à la fois ? Par exemple, "Si l'utilisateur est majeur ET qu'il possède un abonnement, alors accorder la réduction".

Dans la prochaine leçon, nous apprendrons à combiner des conditions en utilisant les opérateurs logiques (ET, OU, NON), ce qui nous permettra de construire une logique de décision encore plus fine et puissante.