Chapitre 3 — Les conditions et les tests logiques

Pourquoi utiliser des conditions ?

On peut comparer une condition à un feu de signalisation :
si le feu est vert, on avance ; s’il est rouge, on s’arrête.
De même, un algorithme exécute certaines instructions seulement si la condition est remplie.

Début
    Lire âge
    Si âge >= 18 Alors
        Écrire "Tu es majeur."
    FinSi
Fin

L’algorithme vérifie si l’âge est supérieur ou égal à 18. Si c’est le cas, il affiche un message. Sinon, il ne fait rien.

L’instruction SI…ALORS…SINON

Si condition Alors
    instructions à exécuter si la condition est vraie
Sinon
    instructions à exécuter sinon
FinSi

Cette structure est appelée conditionnelle car elle dépend d’un test : l’algorithme vérifie une condition avant d’agir. Si la condition est vraie, il exécute la première partie ; sinon, il passe à la seconde.

Début
    Lire température
    Si température \leq 0 Alors
        Écrire "Il gèle !"
    Sinon
        Écrire "La température est positive."
    FinSi
Fin

Ici, la variable température est évaluée. Si sa valeur est inférieure à 0, l’algorithme affiche « Il gèle ! ». Sinon, il affiche « La température est positive. »

Ce type de structure est appelé test binaire, car il n’existe que deux chemins possibles : un chemin pour la condition vraie, un autre pour la condition fausse.

L’instruction conditionnelle est donc une bifurcation : c’est comme un croisement sur une route. Selon la situation, l’algorithme choisit de tourner à gauche ou à droite, mais jamais les deux à la fois.

Début
    Lire température
    Si température \leq 0 Alors
        Écrire "Attention, il gèle !"
    FinSi
    Écrire "Programme terminé."
Fin

Dans cet exemple, l’algorithme affiche un message supplémentaire uniquement si la condition est vraie. Si la température est de 10, aucune alerte n’est affichée, mais le programme continue normalement.

Cette manière de faire est très fréquente, car de nombreux cas ne nécessitent pas d’alternative spécifique. Elle simplifie la lecture et évite les branches inutiles.

Enfin, il est important de remarquer que la condition évaluée doit toujours être une expression logique. Autrement dit, elle doit pouvoir être vraie ou fausse. Par exemple :

Si âge >= 18 Alors
    Écrire "Majeur"
Sinon
    Écrire "Mineur"
FinSi

Ici, le test âge >= 18 est une expression logique : il renvoie Vrai si l’âge est supérieur ou égal à 18, et Faux sinon. C’est ce résultat qui décide du chemin pris par l’algorithme.

Les opérateurs logiques

Parfois, une seule condition ne suffit pas à décrire une situation réelle.
On veut par exemple tester si un nombre est dans un intervalle, ou si un élève a réussi ou est en rattrapage.
C’est là qu’interviennent les opérateurs logiques, qui permettent de relier plusieurs tests entre eux.

| Opérateur | Signification | Exemple | Résultat | | ---------------- | ------------------------------------------ | ----------------------------- | --------------------------------------- | | et | Les deux conditions doivent être vraies | x > 0 et x \leq 10 | Vrai si x est compris entre 0 et 10 | | ou | Au moins une des deux conditions est vraie | x \leq 0 ou x > 100 | Vrai si x est en dehors de l’intervalle | | non | Inverse le résultat de la condition | non(x > 5) | Vrai si x ≤ 5 |

Ces opérateurs permettent d’exprimer des raisonnements logiques :

et correspond à une double condition obligatoire (comme "il fait chaud et il fait beau"),
ou indique une alternative (comme "je prendrai du café ou du thé"),
non renverse une affirmation (comme "je ne suis pas fatigué").

Début
    Lire note
    Si note >= 10 et note \leq 12 Alors
        Écrire "Passable"
    Si note >= 12 et note \leq 16 Alors
        Écrire "Assez bien"
    Si note >= 16 Alors
        Écrire "Très bien"
Fin

Dans cet algorithme, chaque condition décrit un intervalle précis de valeurs pour note. Si la note est de 11, seule la première condition sera vraie ; si elle vaut 14, seule la deuxième s’applique ; et ainsi de suite. Cela montre que l’algorithme choisit dynamiquement le bon chemin en fonction des valeurs fournies.

Les opérateurs logiques permettent donc de rendre les tests plus expressifs, en rapprochant le raisonnement du langage naturel.

Les opérateurs logiques sont à la base de tout raisonnement informatique. Ils permettent à un programme de poser des questions complexes, d’analyser plusieurs situations à la fois et d’adapter son comportement selon les réponses obtenues.

Les conditions imbriquées et multiples

Exemple de condition imbriquée

Début
    Lire âge
    Si âge >= 18 Alors
        Lire permis
        Si permis = "oui" Alors
            Écrire "Tu peux conduire."
        Sinon
            Écrire "Tu es majeur mais sans permis."
        FinSi
    Sinon
        Écrire "Tu es mineur."
    FinSi
Fin

L’algorithme pose d’abord une question (âge), puis une autre (permis) seulement si la première condition est remplie. C’est un raisonnement hiérarchique.

Exemple de condition multiple

Si note >= 16 Alors
    Écrire "Très bien"
SinonSi note >= 12 Alors
    Écrire "Assez bien"
SinonSi note >= 10 Alors
    Écrire "Passable"
Sinon
    Écrire "Insuffisant"
FinSi

Ici, une seule condition est vraie à la fois. Dès qu’une branche est exécutée, les autres sont ignorées.

Applications directes

Les conditions permettent à un algorithme de s’adapter à des situations variées.
Dans les exemples suivants, vous verrez comment elles peuvent être utilisées pour faire des choix logiques selon les valeurs saisies par l’utilisateur.

Exercice 1 :
Écrire un algorithme qui lit un nombre et affiche s’il est positif, négatif ou nul.

Début
    Lire n
    Si n > 0 Alors
        Écrire "Positif"
    SinonSi n \leq 0 Alors
        Écrire "Négatif"
    Sinon
        Écrire "Nul"
    FinSi
Fin

Entrée : -7 Sortie : Négatif

Cet algorithme commence par lire un nombre. Il teste ensuite trois cas possibles :

Si la valeur est supérieure à zéro, elle est positive.
Si elle est inférieure à zéro, elle est négative.
Si elle n’est ni l’un ni l’autre, elle est forcément nulle (égale à zéro).

Ce type de structure est très courant : il permet de distinguer clairement des situations exclusives, c’est-à-dire des cas qui ne peuvent pas être vrais en même temps.

Pour s’en souvenir, on peut imaginer une balance :

à gauche (valeurs négatives), le plateau descend,
à droite (valeurs positives), il monte,
au centre, la balance reste en équilibre (zéro).

Ainsi, l’algorithme agit comme une balance logique, déterminant de quel côté penche le nombre.

Exercice 2 : Écrire un algorithme qui lit l’âge d’une personne et affiche un tarif selon sa catégorie.

Début
    Lire âge
    Si âge \leq 12 Alors
        Écrire "Tarif enfant"
    SinonSi âge \leq 26 Alors
        Écrire "Tarif jeune"
    SinonSi âge >= 65 Alors
        Écrire "Tarif senior"
    Sinon
        Écrire "Tarif plein"
    FinSi
Fin

Entrée : 20 Sortie : Tarif jeune

Cet algorithme lit l’âge et choisit la catégorie tarifaire correspondante :

Moins de 12 ans : tarif enfant
Moins de 26 ans : tarif jeune
65 ans et plus : tarif senior
Tous les autres âges : tarif plein

Le principe repose sur un enchaînement de conditions évaluées dans l’ordre. Dès qu’une condition est vraie, l’algorithme exécute l’instruction correspondante et ignore les suivantes.

Cela reproduit le raisonnement humain : « Si la personne est un enfant, je lui applique le tarif enfant. Sinon, si c’est un jeune, je lui applique le tarif jeune. Sinon, si c’est un senior, je lui applique le tarif senior. Sinon, c’est un adulte et je lui donne le tarif plein. »