Imbrication de conditions | Algorithmique et programmation | 10 Exercices corrigés

Concepts & Exercices

\(\text{if } P \text{ then } S_1 \text{ else if } Q \text{ then } S_2 \text{ else } S_3\)

\(\text{Structure conditionnelle imbriquée}\)

Hiérarchie des instructions conditionnelles

Condition simple

if P:
action

Une seule branche

If-Else

if P:
action1
else:
action2

Deux branches alternatives

If-Elif-Else

if P:
  action1
elif Q:
  action2
else:
  action3

Plusieurs alternatives

Imbrication

if P:
  if Q:
    action1
  else:
    action2

Condition dans une condition

🎯

Définition : Une structure conditionnelle imbriquée contient une condition à l'intérieur d'une autre.

🔗

Hiérarchie : Les conditions internes ne sont évaluées que si la condition externe est vraie.

✅

Indentation : Essentielle en Python pour structurer les blocs conditionnels.

📊

Flux : Contrôle le chemin d'exécution selon les valeurs des variables.

💡

Conseil : Dessinez un arbre de décision pour visualiser les chemins possibles

🔍

Attention : Chaque indentation correspond à un niveau de profondeur

⚡

Astuce : Numérotez les blocs pour suivre l'ordre d'exécution

📋

Méthode : Évaluez du plus externe au plus interne

Exercice 1

Soit age = 18, permis = True. Quel bloc s'exécute dans l'imbrication ?

Exercice 2

Soit a = 10, b = 5. Évaluer l'imbrication de conditions pour a > 8 et b < 6

Exercice 3

Soit x = 3, y = 7. Évaluer l'imbrication avec x > 5 et y > 5

Exercice 4

Soit temp = 25, soleil = True. Évaluer l'imbrication pour sortie possible

Exercice 5

Soit note = 14, coef = 2. Évaluer l'imbrication pour mention

Exercice 6

Soit a = 15, b = 8, c = 12. Évaluer l'imbrication de trois conditions

Exercice 7

Soit x = -2, y = 4. Évaluer l'imbrication avec conditions négatives

Exercice 8

Soit heure = 14, weekend = False. Évaluer l'imbrication pour ouverture magasin

Exercice 9

Soit a = 7, b = 3, c = 9. Évaluer l'imbrication avec multiple elif

Exercice 10

Soit x = 5, y = 8, z = 3. Évaluer l'imbrication complexe de trois niveaux

Corrigé : Exercices 1 à 5

1 Imbrication avec age et permis

Définition :

Imbrication : Structure où une condition est placée à l'intérieur d'une autre.

Méthode d'évaluation :

Évaluer la condition externe en premier
Si vraie, évaluer la condition interne
Exécuter le bloc correspondant

Code Python

                age = 18

                permis = True

                if age >= 18:

                  if permis:

                    print("Peut conduire")

                  else:

                    print("N'a pas le permis")

                else:

                  print("Trop jeune")

Étape 1 : Évaluer la condition externe

age >= 18 avec age = 18 → 18 >= 18 → VRAI

Étape 2 : Évaluer la condition interne (puisque externe est vraie)

permis avec permis = True → VRAI

Étape 3 : Exécuter le bloc correspondant

Le bloc "Peut conduire" s'exécute

Réponse finale :

Le message "Peut conduire" sera affiché

Règles appliquées :

• Hiérarchie : La condition interne n'est évaluée que si la condition externe est vraie

• Indentation : Indique l'appartenance à un bloc

• Flux d'exécution : Suit l'arborescence des conditions

2 Imbrication avec a = 10 et b = 5

Définition :

Évaluation séquentielle : Les conditions sont évaluées dans l'ordre d'imbrication.

Code Python

                a = 10

                b = 5

                if a > 8:

                  if b < 6:

                    result = "Les deux conditions sont vraies"

                  else:

                    result = "a > 8 mais b >= 6"

                else:

                  result = "a <= 8"

                print(result)

Étape 1 : Évaluer la condition externe

a > 8 avec a = 10 → 10 > 8 → VRAI

Étape 2 : Évaluer la condition interne

b < 6 avec b = 5 → 5 < 6 → VRAI

Étape 3 : Exécuter le bloc correspondant

Le bloc interne s'exécute car les deux conditions sont vraies

Réponse finale :

Le message "Les deux conditions sont vraies" sera affiché

Règles appliquées :

• Ordre d'évaluation : Externe d'abord, puis interne

• Logique : Les conditions internes ne sont testées que si externes sont vraies

• Contrôle de flux : Dirige le programme selon les valeurs des variables

3 Imbrication avec x = 3 et y = 7

Définition :

Chemins alternatifs : Différents blocs peuvent s'exécuter selon les conditions.

Code Python

                x = 3

                y = 7

                if x > 5:

                  if y > 5:

                    result = "x et y sont grands"

                  else:

                    result = "x est grand, y est petit"

                else:

                  if y > 5:

                    result = "x est petit, y est grand"

                  else:

                    result = "x et y sont petits"

                print(result)

Étape 1 : Évaluer la condition externe

x > 5 avec x = 3 → 3 > 5 → FAUX

Étape 2 : Puisque la condition externe est fausse, aller au else

On entre dans le bloc else

Étape 3 : Évaluer la condition interne dans le else

y > 5 avec y = 7 → 7 > 5 → VRAI

Étape 4 : Exécuter le bloc correspondant

"x est petit, y est grand" s'affiche

Réponse finale :

Le message "x est petit, y est grand" sera affiché

Règles appliquées :

• Évaluation alternative : Si la condition principale est fausse, on passe au else

• Structure arborescente : Chaque branche peut contenir ses propres conditions

• Complétude : Tous les cas possibles sont couverts

4 Imbrication avec température et soleil

Définition :

Conditions multiples : Plusieurs critères pour une décision.

Code Python

                temp = 25

                soleil = True

                if temp > 20:

                  if soleil:

                    activite = "Sortie possible, temps agréable"

                  else:

                    activite = "Température bonne mais nuageux"

                else:

                  if soleil:

                    activite = "Soleil mais froid"

                  else:

                    activite = "Temps désagréable"

                print(activite)

Étape 1 : Évaluer la condition externe

temp > 20 avec temp = 25 → 25 > 20 → VRAI

Étape 2 : Évaluer la condition interne

soleil avec soleil = True → VRAI

Étape 3 : Exécuter le bloc correspondant

"Sortie possible, temps agréable" s'affiche

Réponse finale :

Le message "Sortie possible, temps agréable" sera affiché

Règles appliquées :

• Combinaison de critères : Plusieurs variables influencent la décision

• Logique combinée : Les conditions internes dépendent des externes

• Prise de décision : Basée sur plusieurs facteurs

5 Imbrication avec note et coefficient

Définition :

Évaluation conditionnelle : Décision basée sur des seuils.

Code Python

                note = 14

                coef = 2

                if note >= 10:

                  if note >= 16:

                    mention = "Très bien"

                  elif note >= 14:

                    mention = "Bien"

                  else:

                    mention = "Passable"

                else:

                  mention = "Insuffisant"

                print(f"Mention: {mention}")

Étape 1 : Évaluer la condition externe

note >= 10 avec note = 14 → 14 >= 10 → VRAI

Étape 2 : Évaluer la première condition interne

note >= 16 avec note = 14 → 14 >= 16 → FAUX

Étape 3 : Évaluer la condition elif interne

note >= 14 avec note = 14 → 14 >= 14 → VRAI

Étape 4 : Exécuter le bloc correspondant

Le bloc "Bien" s'exécute

Réponse finale :

Le message "Mention: Bien" sera affiché

Règles appliquées :

• Échelonnement : Les seuils sont évalués dans l'ordre décroissant

• Évaluation exclusive : Un seul bloc est exécuté dans une structure if-elif-else

• Hiérarchie des mentions : Les mentions supérieures excluent les inférieures

Corrigé : Exercices 6 à 10

6 Imbrication avec trois variables

Définition :

Complexité croissante : Plus de variables augmente les combinaisons possibles.

Code Python

                a = 15

                b = 8

                c = 12

                if a > 10:

                  if b > 5:

                    if c > 10:

                      result = "Tous supérieurs aux seuils"

                    else:

                      result = "a et b OK, c non"

                  else:

                    result = "a OK, b non"

                else:

                  result = "a non OK"

                print(result)

Étape 1 : Évaluer la condition la plus externe

a > 10 avec a = 15 → 15 > 10 → VRAI

Étape 2 : Évaluer la condition intermédiaire

b > 5 avec b = 8 → 8 > 5 → VRAI

Étape 3 : Évaluer la condition la plus interne

c > 10 avec c = 12 → 12 > 10 → VRAI

Étape 4 : Exécuter le bloc correspondant

Le bloc le plus interne s'exécute

Réponse finale :

Le message "Tous supérieurs aux seuils" sera affiché

Règles appliquées :

• Imbrication profonde : Trois niveaux de conditions

• Évaluation séquentielle : Du plus externe au plus interne

• Logique hiérarchique : Chaque niveau dépend du précédent

7 Imbrication avec valeurs négatives

Définition :

Nombres négatifs : Traitement spécial des valeurs inférieures à zéro.

Code Python

                x = -2

                y = 4

                if x < 0:

                  if y > 0:

                    result = "x négatif, y positif"

                  else:

                    result = "x et y négatifs"

                else:

                  if y > 0:

                    result = "x et y positifs"

                  else:

                    result = "x positif, y négatif"

                print(result)

Étape 1 : Évaluer la condition externe

x < 0 avec x = -2 → -2 < 0 → VRAI

Étape 2 : Évaluer la condition interne

y > 0 avec y = 4 → 4 > 0 → VRAI

Étape 3 : Exécuter le bloc correspondant

Le bloc "x négatif, y positif" s'exécute

Réponse finale :

Le message "x négatif, y positif" sera affiché

Règles appliquées :

• Signe des nombres : Traitement différent pour positifs/négatifs

• Classification : Catégorisation basée sur le signe

• Logique de classification : Plusieurs critères pour classer les données

8 Imbrication pour horaires d'ouverture

Définition :

Horaires conditionnels : Ouverture dépend de plusieurs critères.

Code Python

                heure = 14

                weekend = False

                if not weekend:

                  if 9 <= heure <= 18:

                    etat_magasin = "Ouvert"

                  else:

                    etat_magasin = "Fermé (hors horaires)"

                else:

                  if 10 <= heure <= 17:

                    etat_magasin = "Ouvert (weekend)"

                  else:

                    etat_magasin = "Fermé (weekend hors horaires)"

                print(etat_magasin)

Étape 1 : Évaluer la condition externe

not weekend avec weekend = False → not False → VRAI

Étape 2 : Évaluer la condition interne

9 <= heure <= 18 avec heure = 14 → 9 <= 14 <= 18 → VRAI

Étape 3 : Exécuter le bloc correspondant

Le magasin est "Ouvert"

Réponse finale :

Le message "Ouvert" sera affiché

Règles appliquées :

• Logique temporelle : Différents horaires selon les jours

• Intervalle : Utilisation d'intervalles pour les heures

• Logique métier : Règles spécifiques à un contexte

9 Imbrication avec multiple elif

Définition :

Structures complexes : Combinaison d'imbrication et de structures alternatives.

Code Python

                a = 7

                b = 3

                c = 9

                if a > 5:

                  if b > 5:

                    result = "a et b > 5"

                  elif c > 5:

                    result = "a > 5 et c > 5"

                  else:

                    result = "seulement a > 5"

                else:

                  if b > 5:

                    result = "seulement b > 5"

                  elif c > 5:

                    result = "seulement c > 5"

                  else:

                    result = "aucun > 5"

                print(result)

Étape 1 : Évaluer la condition externe

a > 5 avec a = 7 → 7 > 5 → VRAI

Étape 2 : Évaluer la condition interne

b > 5 avec b = 3 → 3 > 5 → FAUX

Étape 3 : Évaluer la condition elif interne

c > 5 avec c = 9 → 9 > 5 → VRAI

Étape 4 : Exécuter le bloc correspondant

Le bloc "a > 5 et c > 5" s'exécute

Réponse finale :

Le message "a > 5 et c > 5" sera affiché

Règles appliquées :

• Combinaison : Imbrication + structures alternatives

• Évaluation exclusive : Dans chaque ensemble if-elif-else, un seul bloc s'exécute

• Logique combinatoire : Plusieurs critères combinés pour la décision

10 Imbrication complexe trois niveaux

Définition :

Imbrication maximale : Trois niveaux de conditions imbriquées.

Code Python

                x = 5

                y = 8

                z = 3

                if x > 4:

                  print("Niveau 1: x > 4")

                  if y > 6:

                    print("Niveau 2: y > 6")

                    if z > 2:

                      result = "Toutes les conditions vraies"

                      print("Niveau 3: z > 2")

                    else:

                      result = "x > 4 et y > 6 mais z <= 2"

                  else:

                    result = "x > 4 mais y <= 6"

                else:

                  result = "x <= 4"

                print(result)

Étape 1 : Évaluer la condition de niveau 1

x > 4 avec x = 5 → 5 > 4 → VRAI

Étape 2 : Évaluer la condition de niveau 2

y > 6 avec y = 8 → 8 > 6 → VRAI

Étape 3 : Évaluer la condition de niveau 3

z > 2 avec z = 3 → 3 > 2 → VRAI

Étape 4 : Exécuter le bloc correspondant

Tous les messages s'affichent, le résultat est "Toutes les conditions vraies"

Réponse finale :

Les messages "Niveau 1: x > 4", "Niveau 2: y > 6", "Niveau 3: z > 2" et "Toutes les conditions vraies" seront affichés

Règles appliquées :

• Profondeur maximale : Trois niveaux d'imbrication

• Flux d'exécution : Suit l'arborescence des conditions

• Logique hiérarchique : Chaque niveau dépend du précédent

Imbrication de conditionsAlgorithmique et programmation

Imbrication de conditions
Algorithmique et programmation