# Conditions Composées Les conditions sont des éléments fondamentaux de l'algorithmique, permettant de contrôler le flux d'exécution d'un programme en fonction de l'état des données. Alors que les conditions simples évaluent une seule expression, les conditions composées permettent d'évaluer plusieurs expressions logiques simultanément, offrant ainsi une flexibilité accrue dans la prise de décision. Ce chapitre explorera les opérateurs logiques qui permettent de construire ces conditions complexes. > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/K3p3WfuIB3c?si=Z861f_IycMapGWJT" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## 1. Introduction aux Conditions Composées En algorithmique, une condition est une expression qui peut être évaluée comme vraie (VRAI) ou fausse (FAUX). Jusqu'à présent, nous avons manipulé des conditions simples (ex: `age > 18`, `est_connecte = VRAI`). Cependant, il est souvent nécessaire de prendre des décisions basées sur plusieurs critères simultanés. C'est là qu'interviennent les conditions composées. > [!definition] Condition Composée > Une condition composée est une expression logique formée en combinant deux ou plusieurs conditions simples à l'aide d'opérateurs logiques. Elle évalue la véracité de plusieurs propositions afin de déterminer une unique valeur VRAI ou FAUX. Ce concept s'appuie directement sur les principes de la **Logique Combinatoire** (algèbre de Boole), où des propositions sont combinées pour former des expressions logiques plus complexes. ## 2. Opérateurs Logiques Les opérateurs logiques permettent de lier des conditions simples entre elles. Les trois opérateurs fondamentaux sont ET (AND), OU (OR) et NON (NOT). ### 2.1 Opérateur ET (AND) L'opérateur ET (logique) renvoie VRAI si et seulement si *toutes* les conditions qu'il relie sont vraies. > [!theorem] Propriété de l'opérateur ET > Soient $A$ et $B$ deux conditions logiques. L'expression $A \text{ ET } B$ est VRAIE si $A$ est VRAIE **et** $B$ est VRAIE. Dans tous les autres cas, elle est FAUSSE. | A | B | A ET B | | :---- | :---- | :----- | | VRAI | VRAI | VRAI | | VRAI | FAUX | FAUX | | FAUX | VRAI | FAUX | | FAUX | FAUX | FAUX | > [!example] Exemple avec ET > Supposons que nous voulions vérifier si un utilisateur est majeur *et* possède un permis de conduire valide. > > ```pseudo-code > SI (age >= 18 ET a_permis = VRAI) ALORS > { > AFFICHER "Accès autorisé à la location de véhicule." > } > SINON > { > AFFICHER "Accès refusé : conditions non remplies." > } > ``` ### 2.2 Opérateur OU (OR) L'opérateur OU (logique) renvoie VRAI si *au moins une* des conditions qu'il relie est vraie. > [!theorem] Propriété de l'opérateur OU > Soient $A$ et $B$ deux conditions logiques. L'expression $A \text{ OU } B$ est VRAIE si $A$ est VRAIE **ou** $B$ est VRAIE (ou les deux). Elle est FAUSSE uniquement si $A$ est FAUSSE **et** $B$ est FAUSSE. | A | B | A OU B | | :---- | :---- | :----- | | VRAI | VRAI | VRAI | | VRAI | FAUX | VRAI | | FAUX | VRAI | VRAI | | FAUX | FAUX | FAUX | > [!example] Exemple avec OU > Supposons que nous voulions vérifier si un étudiant a réussi l'examen *ou* a validé son projet. > > ```pseudo-code > SI (note_examen >= 10 OU note_projet >= 10) ALORS > { > AFFICHER "L'étudiant a validé le module." > } > SINON > { > AFFICHER "L'étudiant n'a pas validé le module." > } > ``` ### 2.3 Opérateur NON (NOT) L'opérateur NON (logique) inverse la valeur de vérité d'une condition. Si la condition est vraie, NON la rend fausse, et vice-versa. > [!theorem] Propriété de l'opérateur NON > Soit $A$ une condition logique. L'expression $\text{NON } A$ est VRAIE si $A$ est FAUSSE. Elle est FAUSSE si $A$ est VRAIE. | A | NON A | | :---- | :---- | | VRAI | FAUX | | FAUX | VRAI | > [!example] Exemple avec NON > Supposons que nous voulions exécuter une action si une variable `est_connecte` est fausse. > > ```pseudo-code > SI (NON est_connecte) ALORS > { > AFFICHER "Veuillez vous connecter pour continuer." > APPELER fonction_connexion() > } > SINON > { > AFFICHER "Bienvenue, vous êtes déjà connecté." > } > ``` ## 3. Priorité des Opérateurs Logiques Lorsque plusieurs opérateurs logiques sont utilisés dans une même expression, un ordre de priorité est appliqué, similaire à celui des opérateurs arithmétiques. > [!note] Ordre de priorité > 1. **NON** (plus haute priorité) > 2. **ET** > 3. **OU** (plus basse priorité) > > Il est toujours possible d'utiliser des parenthèses `()` pour forcer un ordre d'évaluation différent ou pour améliorer la lisibilité du code, même si l'ordre par défaut est respecté. > [!example] Exemple de priorité > L'expression `A OU B ET C` est évaluée comme `A OU (B ET C)`. > Si l'on souhaite que le OU soit évalué en premier, il faut écrire `(A OU B) ET C`. ## 4. Conditions Composées Avancées Il est possible de combiner ces opérateurs pour former des conditions très complexes. > [!example] Exemple combiné > Imaginons un système de réservation où une place est disponible si : > 1. Elle n'est pas déjà réservée (`NON est_reservee`). > 2. ET (l'utilisateur est un membre Premium OU le prix est inférieur à 50 euros). > > ```pseudo-code > SI (NON est_reservee ET (est_membre_premium = VRAI OU prix < 50)) ALORS > { > AFFICHER "La place est disponible pour réservation." > RESERVER_PLACE() > } > SINON > { > AFFICHER "La place n'est pas disponible ou les conditions ne sont pas remplies." > } > ``` > [!tip] Clarté et lisibilité > Même si les parenthèses ne sont pas toujours obligatoires en raison de la priorité des opérateurs, leur utilisation peut grandement améliorer la lisibilité et réduire les erreurs logiques dans les conditions complexes. ## 5. Transition vers la Programmation Dans les langages de programmation réels, comme **Python** (qui sera abordé prochainement), ces opérateurs logiques sont généralement représentés par des mots-clés spécifiques : - `ET` devient `and` - `OU` devient `or` - `NON` devient `not` La logique sous-jacente reste la même, ce qui facilite la transition de l'algorithmique vers l'implémentation concrète. ## Résumé Les conditions composées sont essentielles pour la prise de décision complexe en algorithmique. Elles s'appuient sur les opérateurs logiques ET, OU et NON, dont la compréhension est fondamentale : - **ET** (`AND`): VRAI si toutes les conditions sont VRAIES. - **OU** (`OR`): VRAI si au moins une condition est VRAIE. - **NON** (`NOT`): Inverse la valeur de vérité d'une condition. - L'ordre de priorité est **NON > ET > OU**, mais les parenthèses peuvent être utilisées pour clarifier ou modifier cet ordre. La maîtrise de ces concepts permet de construire des algorithmes robustes et capables de gérer une multitude de scénarios. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]