Décision et Logique Conditionnelle

Introduction

Au cours des leçons précédentes de ce module, nous avons posé des bases solides pour la prise de décision en algorithmique. Nous avons vu :

• La structure de base Si...Alors...Sinon pour créer des chemins d'exécution alternatifs.
• L'imbrication de ces structures (Si...SinonSi...) pour gérer des cas multiples.
• L'utilisation des opérateurs logiques (ET, OU, NON) pour construire des conditions complexes.
• La traduction de cette logique en organigrammes pour la visualiser.

Aujourd'hui, nous allons assembler toutes ces pièces. L'objectif est de résoudre un problème pratique complet dont la logique repose sur des choix. Nous allons partir d'un énoncé concret, analyser ses règles, concevoir une solution robuste et l'écrire en pseudo-code. C'est une étape essentielle pour développer la rigueur nécessaire à l'écriture de "code clean", votre objectif final.

1. La Méthode : De l'Énoncé à l'Algorithme

Pour aborder un problème de manière structurée, il est utile de suivre une méthode. Voici une approche en quatre étapes que nous appliquerons tout au long de cette leçon :

1. Analyser l'énoncé : Décomposer le problème pour identifier clairement :

   • Les entrées : Quelles informations sont fournies à l'algorithme ?
   • Les sorties : Quel résultat l'algorithme doit-il produire ?
   • Les règles de décision : Quelles sont les conditions qui déterminent la sortie ?

2. Traduire les règles en logique : Transformer les règles (souvent en langage courant) en une structure logique formelle. Cela peut prendre deux formes :

   • Une expression logique unique combinant plusieurs tests avec ET et OU.
   • Un arbre de décision qui se traduira par des Si...SinonSi...Sinon imbriqués.

3. Écrire le pseudo-code : Rédiger l'algorithme complet en suivant la logique définie à l'étape précédente.

4. Tester l'algorithme : Vérifier que l'algorithme fonctionne correctement en le traçant manuellement avec un jeu de données de test. Il faut inclure :

   • Des cas nominaux (ex : des valeurs attendues).
   • Des cas limites (ex : des valeurs qui se trouvent juste à la frontière d'une condition).

2. Étude de Cas Guidée : L'Année Bissextile

Appliquons cette méthode à un problème classique : déterminer si une année est bissextile.

Étape 1 : Analyser l'énoncé

Pour commencer, nous devons connaître les règles exactes.

Synthétisons notre analyse :

• Entrée : Une variable annee de type Entier.
• Sortie : Un message indiquant si l'année est "bissextile" ou "non bissextile".
• Règles : Une année est bissextile si...
  1. Elle est divisible par 4, ET
  2. Elle n'est pas divisible par 100,
  3. SAUF SI elle est divisible par 400 (dans ce cas, elle est bissextile malgré tout).

Pour vérifier la divisibilité, nous utiliserons l'opérateur MOD (modulo). L'expression a MOD b donne le reste de la division entière de a par b. Donc, annee MOD 4 = 0 signifie que annee est divisible par 4.

Étape 2 : Traduire les règles en logique

Nous pouvons aborder cela de deux manières.

Approche 1 : Une seule expression logique
On peut combiner toutes les règles en une seule condition complexe. L'année est bissextile si :
(elle est divisible par 4 ET non divisible par 100) OU (elle est divisible par 400).

Ce qui se traduit par :
((annee MOD 4 = 0) ET (annee MOD 100 != 0)) OU (annee MOD 400 = 0)

Approche 2 : Un arbre de décision (logique imbriquée)
On peut aussi suivre les règles comme une série de questions :

1. L'année est-elle divisible par 4 ?
   • Non -> Elle n'est pas bissextile.
   • Oui -> On doit vérifier plus de choses. On pose une deuxième question :
     2. L'année est-elle divisible par 100 ?
     - Non -> Elle est bissextile (car divisible par 4 et pas par 100).
     - Oui -> On doit encore affiner. On pose une troisième question :
     3. L'année est-elle divisible par 400 ?
     - Oui -> Elle est bissextile (c'est l'exception de l'exception).
     - Non -> Elle n'est pas bissextile (divisible par 100 mais pas par 400).

Cette seconde approche est souvent plus intuitive et mène à un code plus lisible.

Étape 3 : Écrire le pseudo-code

Traduisons maintenant la deuxième approche (logique imbriquée) en pseudo-code.

Algorithme AnneeBissextile
  Variable
    annee : Entier
  Début
    Ecrire("Entrez une année :")
    Lire(annee)

    Si (annee MOD 4 = 0) Alors
      Si (annee MOD 100 = 0) Alors
        Si (annee MOD 400 = 0) Alors
          Ecrire(annee, " est une année bissextile.")
        Sinon
          Ecrire(annee, " n'est pas une année bissextile.")
        FinSi
      Sinon
        Ecrire(annee, " est une année bissextile.")
      FinSi
    Sinon
      Ecrire(annee, " n'est pas une année bissextile.")
    FinSi
  Fin

Étape 4 : Tester l'algorithme

Traçons manuellement l'exécution pour quelques cas :

• annee = 2023 :

  1. 2023 MOD 4 != 0. La première condition est fausse.
  2. L'algorithme va directement au dernier Sinon.
  3. Sortie : "2023 n'est pas une année bissextile." (Correct)

• annee = 2024 (cas nominal bissextile) :

  1. 2024 MOD 4 = 0. La première condition est vraie. On entre dans le premier Si.
  2. 2024 MOD 100 != 0. La deuxième condition est fausse. On va au Sinon correspondant.
  3. Sortie : "2024 est une année bissextile." (Correct)

• annee = 1900 (cas limite non bissextile) :

  1. 1900 MOD 4 = 0. Vrai.
  2. 1900 MOD 100 = 0. Vrai. On entre dans le deuxième Si.
  3. 1900 MOD 400 != 0. Faux. On va au Sinon correspondant.
  4. Sortie : "1900 n'est pas une année bissextile." (Correct)

• annee = 2000 (cas limite bissextile) :

  1. 2000 MOD 4 = 0. Vrai.
  2. 2000 MOD 100 = 0. Vrai.
  3. 2000 MOD 400 = 0. Vrai.
  4. Sortie : "2000 est une année bissextile." (Correct)

L'algorithme semble robuste !

3. Mise en Pratique : À vous de jouer !

Maintenant, à votre tour d'appliquer la méthode sur un nouveau problème.

Problème : Catégoriser un enfant par âge
Un club de sport souhaite un algorithme qui, en fonction de l'âge d'un enfant, affiche sa catégorie. Les règles sont les suivantes :

• De 6 à 7 ans : "Poussin"
• De 8 à 9 ans : "Pupille"
• De 10 à 11 ans : "Minime"
• À partir de 12 ans : "Cadet"
• En dessous de 6 ans, l'enfant est trop jeune.

Je vous invite à suivre les 4 étapes : analysez le problème, définissez votre logique (Si...SinonSi...), écrivez le pseudo-code, et testez-le mentalement avec des âges comme 5, 7, 10, et 13.

Algorithme CategorieEnfant
  Variable
    age : Entier
  Début
    Ecrire("Entrez l'âge de l'enfant :")
    Lire(age)

    Si (age >= 12) Alors
      Ecrire("Catégorie Cadet")
    SinonSi (age >= 10) Alors  // Implicitement, age < 12 ici
      Ecrire("Catégorie Minime")
    SinonSi (age >= 8) Alors   // Implicitement, age < 10 ici
      Ecrire("Catégorie Pupille")
    SinonSi (age >= 6) Alors   // Implicitement, age < 8 ici
      Ecrire("Catégorie Poussin")
    Sinon
      Ecrire("L'enfant est trop jeune.")
    FinSi
  Fin

Conclusion

Félicitations ! Vous avez appliqué avec succès une méthode complète pour résoudre des problèmes basés sur des choix complexes. C'est la compétence fondamentale au cœur de ce module.

Les points clés à retenir :

• Une méthode structurée (Analyse, Logique, Pseudo-code, Test) est votre meilleure alliée pour aborder n'importe quel problème algorithmique.
• Pour des règles complexes, la logique imbriquée (Si...SinonSi...) est souvent plus claire et plus facile à maintenir qu'une seule grosse condition ET/OU. C'est un principe de "clean code".
• Le test manuel avec des cas limites (comme 1900, 2000, ou l'âge exact d'un changement de catégorie) est crucial pour garantir la robustesse de votre algorithme.

Et après ?

Nous avons maintenant exploré en profondeur comment faire prendre des décisions à un algorithme. Dans la prochaine et dernière leçon de ce module, nous nous concentrerons sur un autre type de problème pratique : celui où la condition ne détermine pas seulement un message, mais influence directement un calcul, comme l'application d'une remise sur un prix.