Structures Décisionnelles

Ce TP porte sur les structures décisionnelles en algorithmique. Il permet d’apprendre à utiliser les instructions conditionnelles simples, imbriquées et à plusieurs choix pour contrôler le déroulement d’un programme en fonction de conditions. Pour réaliser ce TP, il est nécessaire de disposer d’un environnement de programmation permettant d’écrire et d’exécuter des algorithmes, ainsi que de connaissances de base en variables, lectures et écritures.

Objectifs

• Comprendre et utiliser les structures conditionnelles simples (à un ou deux choix).
• Maîtriser les conditions simples et complexes avec les opérateurs logiques ET, OU, NON.
• Écrire des instructions conditionnelles imbriquées.
• Utiliser les structures conditionnelles à plusieurs choix (branchement multiple).
• Développer des algorithmes pour résoudre des problèmes concrets impliquant des décisions.

Prérequis et mise en place

• Connaissances de base en algorithmique : variables, lecture et écriture.
• Environnement de programmation ou éditeur d’algorithmes permettant d’écrire et d’exécuter des instructions conditionnelles.
• Compréhension des opérateurs de comparaison : >, <, >=, <=, =, <>.
• Notions sur les opérateurs logiques : ET, OU, NON.

Structure conditionnelle simple

Dans cette première étape, vous apprendrez à utiliser une structure conditionnelle à un ou deux choix. Une condition est testée, et selon qu’elle est vraie ou fausse, une action différente est réalisée.

La syntaxe est la suivante :

Si condition alors
  Action1
Fin si

ou

Si condition alors
  Action1
Sinon
  Action2
Fin si

La condition doit être formulée pour n’avoir que deux réponses possibles : oui (vrai) ou non (faux).

Exemple : déterminer le plus grand de deux nombres x et y.

Algorithme plus grand
Var
  x,y,z (Réel)
Début
  Écrire("donner x")
  lire (x)
  écrire ("donner y")
  lire (y)
  si x > y alors
    z  x
  sinon
    z  y
  fin si
  écrire ("le plus grand de", x, "et de", y, "est", z)
Fin

Travail à faire : écrire un programme qui lit un nombre entier puis vérifie s'il est pair ou impair.

Conditions simples et complexes

Une condition peut être simple (par exemple A > B) ou complexe, combinant plusieurs conditions simples avec les opérateurs logiques ET, OU, NON.

Exemple : calculer l’expression 1/x + 1/y seulement si x et y sont différents de zéro.

Algorithme somme_des_inverses
Var
  x,y,s (réel)
Début
  Lire (x,y)
  Si (x <> 0) ET (y <> 0) alors
    s  1/x + 1/y
    écrire (s)
  Fin si
Fin

Structures conditionnelles imbriquées

Une instruction conditionnelle imbriquée est une condition placée à l’intérieur d’une autre condition. Cela permet de gérer plusieurs cas de figure de manière hiérarchique.

Exemple : un robot conduit une voiture et exécute une action selon la couleur du feu (variable Couleur).

Algorithme circulation
Var
  Couleur (chaîne de caractères)
Début
  écrire ("entrer la couleur")
  lire (Couleur)
  Si (Couleur = "Rouge") alors
    écrire ("S’arrêter")
  Sinon
    Si (Couleur = "Vert") alors
      écrire ("Passer")
    Sinon
    Fin si
  Fin Si
  écrire ("Ralentir")
Fin

Travail à faire : écrire un programme qui calcule une remise sur un montant lu en entrée :

• 5% si le montant est compris entre 2000 DT (inclus) et 5000 DT (inclus),
• 10% si le montant est supérieur à 5000 DT.

Structures conditionnelles à plusieurs choix

Lorsque la variable à tester peut prendre plusieurs valeurs distinctes, il est plus efficace d’utiliser une structure conditionnelle à plusieurs choix (branchement multiple) plutôt que plusieurs instructions Si...Alors...Sinon imbriquées.

La syntaxe générale est :

Suivant variable ou expression faire
  <Liste_valeur_1> : instruction 1
  <Liste_valeur_2> : instruction 2
  ...
  <Liste_valeur_n> : instruction n
  [Sinon : instruction par défaut]
Fin Suivant

La variable ou expression doit être scalaire et du même type que les valeurs listées. Si la valeur correspond à une liste, l’instruction associée est exécutée et le branchement s’arrête. Sinon, l’instruction par défaut (optionnelle) est exécutée.

Exemple : afficher un message selon la valeur de la variable nombre.

Suivant nombre faire
  0 : écrire ("Nombre nul")
  1 : écrire ("Nombre égal à 1")
  2,3,5,7 : écrire ("Nombre premier")
  4,6,8..10 : écrire ("Nombre non premier")
  Sinon : écrire ("Nombre négatif ou > 10")
Fin Suivant

Un autre format possible utilise des conditions :

Suivant variable ou expression faire
  <Condition_1> : instruction 1
  <Condition_2> : instruction 2
  ...
  <Condition_n> : instruction n
  [Sinon : instruction par défaut]
Fin Suivant

Si une condition est vérifiée, l’instruction correspondante est exécutée. Sinon, l’instruction par défaut est exécutée si elle existe.

Travail à faire : écrire un programme qui saisit une date sous la forme jj mm aa et affiche le nombre de jours du mois mm ainsi que le nombre de jours restants jusqu’à la fin de ce mois.

Résultats attendus

• Pour la structure conditionnelle simple, le programme doit correctement identifier et afficher le plus grand nombre entre deux valeurs saisies.
• Pour la condition complexe, le calcul de 1/x + 1/y ne doit s’effectuer que si x et y sont différents de zéro, sinon aucune opération n’est faite.
• Dans la structure imbriquée, selon la couleur saisie, le programme affiche "S’arrêter", "Passer" ou "Ralentir".
• Le programme de remise doit appliquer 5% ou 10% selon le montant saisi, ou ne pas appliquer de remise si le montant est inférieur à 2000 DT.
• La structure à plusieurs choix doit afficher le message correct selon la valeur testée, y compris le cas par défaut.
• Le programme de date doit afficher le nombre correct de jours du mois saisi et le nombre de jours restants dans ce mois.

Erreurs courantes

• Oublier de fermer une instruction conditionnelle avec "Fin si" ou "Fin Suivant".
• Formuler une condition qui ne renvoie pas un booléen (vrai/faux) ou qui n’a pas deux issues possibles.
• Confondre l’opérateur d’égalité (=) avec l’affectation () dans les conditions.
• Ne pas gérer le cas où la condition est fausse, surtout dans les structures à un seul choix.
• Dans les conditions imbriquées, mal placer les "Sinon" et "Fin si", ce qui peut provoquer des erreurs de logique ou de syntaxe.
• Dans les structures à plusieurs choix, ne pas inclure un cas "Sinon" pour gérer les valeurs inattendues.
• Pour les conditions complexes, ne pas utiliser correctement les opérateurs ET, OU, NON, ce qui peut fausser la logique.