Opérateurs logiques : ET, OU, NON

Introduction

Dans la leçon précédente, nous avons appris à enchaîner les décisions avec la structure Si...SinonSi...Sinon. Cela nous permet de gérer des situations où plusieurs issues sont possibles, en testant les conditions les unes après les autres.

Cependant, une décision ne dépend pas toujours d'un seul facteur. Pensez à une situation simple : pour obtenir un permis de conduire, il faut avoir au moins 18 ans ET avoir réussi l'examen. Un seul de ces critères ne suffit pas. Comment intégrer cette logique dans nos algorithmes ?

C'est l'objectif de cette leçon : vous allez apprendre à combiner plusieurs conditions en une seule expression logique grâce aux opérateurs ET, OU et NON. La maîtrise de ces opérateurs est une étape cruciale pour construire des raisonnements complexes et précis, une compétence fondamentale pour atteindre votre but de produire un "code clean".

1. Les opérateurs logiques fondamentaux

Un opérateur logique est un mot-clé qui permet de combiner des expressions booléennes (qui valent VRAI ou FAUX) pour produire un unique résultat : VRAI ou FAUX. Il en existe trois de base.

Pour découvrir ces opérateurs, je vous invite à lire un extrait d'un article qui les présente de manière très claire, avec des exemples concrets et des "tables de vérité" qui résument leur comportement.

Synthétisons ce que vous venez de lire en pseudo-code.

L'opérateur ET (AND)

L'opérateur ET est utilisé lorsque toutes les conditions doivent être vraies simultanément.

• Exemple : "Je peux conduire si j'ai 18 ans ou plus ET si j'ai le permis."
• Pseudo-code : Si (age >= 18 ET aLePermis == VRAI) Alors ...
• Table de vérité : Le résultat est VRAI uniquement si les deux conditions sont VRAI.

L'opérateur OU (OR)

L'opérateur OU est utilisé lorsqu'au moins une des conditions doit être vraie.

• Exemple : "Je peux entrer si je suis un employé OU si je suis un invité."
• Pseudo-code : Si (estEmploye == VRAI OU estInvite == VRAI) Alors ...
• Table de vérité : Le résultat est FAUX uniquement si les deux conditions sont FAUX.

L'opérateur NON (NOT)

L'opérateur NON est le plus simple : il inverse la valeur de vérité d'une condition. NON VRAI devient FAUX, et NON FAUX devient VRAI.

• Exemple : "Je sors s'il ne pleut pas."
• Pseudo-code : Si (NON (ilPleut == VRAI)) Alors ... ou plus simplement Si (ilPleut == FAUX) Alors ...
• Table de vérité :

2. Combiner les opérateurs et gérer les priorités

La vraie puissance de ces opérateurs se révèle lorsqu'on les combine pour traduire des règles complexes. Cependant, comme en mathématiques avec +, -, *, /, il existe un ordre de priorité.

Poursuivons notre lecture pour comprendre comment les combiner et quel est leur ordre d'évaluation.

Comme vous l'avez lu, l'ordre de priorité est le suivant :

1. NON est évalué en premier.
2. ET est évalué ensuite.
3. OU est évalué en dernier.

Reprenons l'exemple de l'accès à la zone d'administration : "Un utilisateur peut y accéder s'il est connecté ET (s'il est administrateur OU modérateur)."

Traduction en pseudo-code :
Si (estConnecte == VRAI ET (role == "admin" OU role == "moderateur")) Alors ...

Les parenthèses sont essentielles ici. Elles forcent l'évaluation du OU avant celle du ET. Sans elles, la condition estConnecte == VRAI ET role == "admin" serait évaluée d'abord, ce qui changerait complètement la logique de notre règle.

Règle d'or pour un code clean : En cas de doute, ou même pour simplement améliorer la lisibilité, utilisez toujours des parenthèses pour grouper vos conditions logiques. C'est une excellente habitude à prendre.

3. Mise en pratique

Passons maintenant à la pratique, qui est au cœur de votre apprentissage.

Pratique guidée : Les moments de la journée

Analysons ensemble un exercice qui combine ET et OU au sein d'une structure Si...SinonSi. Le problème est d'afficher le moment de la journée (matin, après-midi, etc.) en fonction de l'heure saisie. La logique pour la nuit est particulièrement intéressante.

Voici le pseudo-code que vous avez analysé :

Algorithme MomentDeLaJournee
  Variable
    heure: Entier
  Début
    Lire(heure)
    Si heure >= 6 ET heure <= 11 Alors
      Ecrire("C'est le matin")
    SinonSi heure >= 12 ET heure <= 16 Alors
      Ecrire("C'est l'après-midi")
    SinonSi heure >= 17 ET heure <= 19 Alors
      Ecrire("C'est le soir")
    SinonSi (heure >= 20 ET heure <= 23) OU (heure >= 0 ET heure <= 5) Alors
      Ecrire("C'est la nuit")
    Sinon
      Ecrire("Heure invalide !")
    FinSi
  Fin

La condition pour "la nuit" montre bien comment combiner les opérateurs :

• La première partie (heure >= 20 ET heure <= 23) vérifie si l'heure est en fin de soirée.
• La seconde partie (heure >= 0 ET heure <= 5) vérifie si l'heure est en début de matinée.
• L'opérateur OU relie les deux, car la nuit correspond à l'un ou l'autre de ces deux intervalles de temps.

À vous de jouer !

Maintenant, à vous de traduire une règle logique en algorithme.

Exercice : Année bissextile

Une année est bissextile si elle respecte l'une des deux règles suivantes :

1. Elle est divisible par 4 mais non divisible par 100.
2. Elle est divisible par 400.

Par exemple :

• 2024 est bissextile (divisible par 4, non par 100).
• 2000 est bissextile (divisible par 400).
• 1900 n'était pas bissextile (divisible par 4 et par 100, mais pas par 400).

Écrivez un algorithme qui demande à l'utilisateur de saisir une année et affiche si elle est bissextile ou non.

Indice : L'opérateur modulo (% ou MOD) est votre ami ! annee MOD 4 == 0 est VRAI si annee est divisible par 4.

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

    // On combine les deux règles avec un OU
    Si ((annee MOD 4 == 0) ET (annee MOD 100 != 0)) OU (annee MOD 400 == 0) Alors
      Ecrire(annee, " est une année bissextile.")
    Sinon
      Ecrire(annee, " n'est pas une année bissextile.")
    FinSi
  Fin

Conclusion

Félicitations ! Vous venez de débloquer une compétence fondamentale. Vous pouvez désormais construire des conditions aussi complexes que la logique du problème l'exige.

Points clés à retenir :

• Les opérateurs ET, OU et NON sont les briques de base de toute logique algorithmique.
• ET exige que toutes les conditions soient vraies.
• OU exige qu'au moins une condition soit vraie.
• NON inverse la valeur d'une condition.
• L'ordre de priorité est NON, puis ET, puis OU.
• L'usage des parenthèses est indispensable pour garantir l'ordre d'évaluation et la lisibilité de votre algorithme.

Et après ?

Maintenant que vous savez écrire des logiques conditionnelles complexes en pseudo-code, comment peut-on s'assurer que notre raisonnement est correct avant même d'écrire la première ligne ? Comment visualiser le flux des décisions ?

Dans la prochaine leçon, nous aborderons une méthode visuelle : vous apprendrez à traduire un algorithme conditionnel en organigramme. Cela vous aidera à concevoir et à vérifier la logique de vos algorithmes d'une manière différente et très intuitive.