# Exercices et Corrigés Détaillés sur les Algorigrammes
## Introduction
Bienvenue dans ce recueil d'exercices et de corrigés, conçu pour solidifier votre compréhension des algorigrammes. En tant que futurs ingénieurs, la capacité à décomposer un problème en étapes logiques et à le représenter de manière claire est une compétence fondamentale. Les algorigrammes sont un excellent point de départ pour développer cette pensée structurée, essentielle avant d'aborder la programmation concrète.
## # Exercices
> [!tip] Comment Aborder les Exercices ?
> Pour chaque exercice, commencez par bien lire l'énoncé. Identifiez les entrées, les traitements nécessaires et les sorties attendues. Dessinez l'algorigramme sur papier avant de le formaliser, cela aide grandement à visualiser le flux logique. N'hésitez pas à tracer l'exécution avec des valeurs d'exemple pour vérifier votre solution.
## Partie 1 : Exercices Très Basiques (Application Directe)
Ces exercices sont conçus pour tester votre compréhension des symboles fondamentaux et de la structure séquentielle simple d'un algorigramme.
### Exercice 1 : Préparer un Café
**Énoncé :**
Vous souhaitez préparer une tasse de café. Décrivez les étapes nécessaires sous forme d'algorigramme simple.
**Objectifs :**
1. Utiliser les symboles de Début/Fin.
2. Représenter une séquence d'actions simples (Traitement).
### Exercice 2 : Somme de Deux Nombres
**Énoncé :**
Créez un algorigramme qui lit deux nombres entiers, calcule leur somme, puis affiche le résultat.
**Objectifs :**
1. Utiliser les symboles d'Entrée/Sortie.
2. Utiliser le symbole de Traitement pour une opération arithmétique.
3. Représenter une séquence d'opérations.
## Partie 2 : Exercices de Niveau Normal (Combinaison de Concepts)
Ces exercices vous demandent de combiner les symboles de base avec les structures de contrôle (conditions et boucles) pour résoudre des problèmes légèrement plus complexes.
### Exercice 3 : Vérification de Parité
**Énoncé :**
Concevez un algorigramme qui lit un nombre entier. Si le nombre est pair, il affiche "Le nombre est pair.". Sinon, il affiche "Le nombre est impair.".
**Objectifs :**
1. Utiliser une structure conditionnelle (Si...Alors...Sinon).
2. Appliquer l'opérateur modulo ($ \%$) pour la vérification de parité.
### Exercice 4 : Compteur Simple
**Énoncé :**
Réalisez un algorigramme qui demande à l'utilisateur de saisir un nombre entier positif $N$. L'algorigramme doit ensuite afficher tous les nombres de 1 jusqu'à $N$ inclus.
**Objectifs :**
1. Utiliser une structure de boucle (par exemple, `Tant que` ou `Pour`).
2. Gérer une variable de compteur.
### Exercice 5 : Calcul du Prix TTC avec Remise
**Énoncé :**
Un magasin propose une remise de 10% sur le prix HT d'un article si son prix HT est supérieur ou égal à 100 €. Le taux de TVA est de 20%.
Créez un algorigramme qui lit le prix HT d'un article, calcule le prix TTC après application éventuelle de la remise, puis affiche ce prix TTC.
**Objectifs :**
1. Combiner une structure conditionnelle avec des opérations de traitement.
2. Gérer plusieurs calculs séquentiels.
### Exercice 6 : Somme des N Premiers Entiers
**Énoncé :**
Élaborez un algorigramme qui demande à l'utilisateur de saisir un nombre entier positif $N$. L'algorigramme doit ensuite calculer et afficher la somme de tous les entiers de 1 à $N$ (c'est-à-dire $1 + 2 + \dots + N$).
**Objectifs :**
1. Utiliser une boucle pour accumuler une somme.
2. Gérer une variable d'accumulateur et une variable de compteur.
## Partie 3 : Exercices Plus Élaborés (Problèmes de Réflexion)
Ces exercices demandent une analyse plus approfondie et la combinaison de plusieurs structures logiques, parfois imbriquées, pour résoudre des problèmes plus complexes.
### Exercice 7 : Calcul de Factorielle
**Énoncé :**
La factorielle d'un nombre entier positif $n$, notée $n!$, est le produit de tous les entiers positifs inférieurs ou égaux à $n$. Par définition, $0! = 1$.
$ n! = n \times (n-1) \times \dots \times 2 \times 1 $
Créez un algorigramme qui demande à l'utilisateur de saisir un nombre entier positif $N$. L'algorigramme doit calculer et afficher la factorielle de $N$. Vous devrez gérer le cas particulier de $N=0$.
**Objectifs :**
1. Implémenter une boucle pour un calcul itératif.
2. Gérer un cas de base (conditionnel).
3. Utiliser une variable d'accumulateur pour le produit.
### Exercice 8 : Racines d'une Équation du Second Degré
**Énoncé :**
Écrivez un algorigramme qui résout une équation du second degré de la forme $ax^2 + bx + c = 0$, où $a, b, c$ sont des coefficients réels. L'algorigramme doit lire les valeurs de $a, b, c$ et afficher les solutions de l'équation.
**Rappel mathématique :**
Le discriminant $\Delta$ est donné par la formule $\Delta = b^2 - 4ac$.
- Si $\Delta > 0$, il y a deux racines réelles distinctes : $x_1 = \frac{-b - \sqrt{\Delta}}{2a}$ et $x_2 = \frac{-b + \sqrt{\Delta}}{2a}$.
- Si $\Delta = 0$, il y a une unique racine réelle (double) : $x_0 = \frac{-b}{2a}$.
- Si $\Delta < 0$, il n'y a pas de racines réelles (deux racines complexes conjuguées, que vous n'aurez pas à calculer ici, juste à indiquer leur non-existence réelle).
**Objectifs :**
1. Utiliser des structures conditionnelles imbriquées ou multiples.
2. Effectuer des calculs mathématiques complexes (racine carrée).
3. Gérer plusieurs cas de sortie différents.
### Exercice 9 : Recherche du Maximum
**Énoncé :**
Créez un algorigramme qui demande à l'utilisateur de saisir une série de nombres entiers positifs. La saisie s'arrête lorsque l'utilisateur entre le nombre 0. L'algorigramme doit ensuite afficher le plus grand nombre parmi tous ceux qui ont été saisis (hors le 0 de fin de saisie). Si aucun nombre n'est saisi (l'utilisateur entre 0 dès le début), l'algorigramme doit afficher un message approprié.
**Objectifs :**
1. Utiliser une boucle `Tant que` pour la saisie répétée.
2. Gérer une variable pour stocker le maximum courant.
3. Gérer un cas particulier (pas de saisie).
4. Préparer le terrain pour la notion de "sentinelle" en programmation.
### Exercice 10 : Simulation de Retrait Bancaire
**Énoncé :**
Concevez un algorigramme qui simule une opération de retrait d'argent à un distributeur.
L'utilisateur entre son solde initial et le montant qu'il souhaite retirer.
Les règles de retrait sont les suivantes :
1. Le montant à retirer doit être un multiple de 10 €.
2. Le montant à retirer ne peut pas dépasser le solde disponible.
3. Le montant à retirer doit être strictement positif.
L'algorigramme doit :
- Lire le solde initial du compte.
- Demander le montant du retrait.
- Vérifier les trois conditions.
- Si toutes les conditions sont remplies, afficher le nouveau solde et un message de confirmation.
- Si une ou plusieurs conditions ne sont pas remplies, afficher un message d'erreur spécifique pour chaque condition non respectée et ne pas effectuer le retrait.
**Objectifs :**
1. Combiner plusieurs conditions logiques (`ET` implicite pour le retrait valide).
2. Utiliser des conditions imbriquées ou une séquence de tests.
3. Gérer différentes sorties d'erreur.
4. Simuler une transaction simple.
---
# Corrigés Détaillés
> [!note] Représentation des Algorigrammes
> Dans ces corrigés, les algorigrammes sont décrits séquentiellement en utilisant les noms des symboles et une brève description de l'action. Par exemple :
> - `[Début]`
> - `[Entrée] : Lire 'variable'`
> - `[Traitement] : 'variable = expression'`
> - `[Décision] : 'Condition ?'` (avec branches `Vrai` et `Faux`)
> - `[Sortie] : Afficher 'message' ou 'variable'`
> - `[Fin]`
>
> Les flèches de flux sont implicites dans l'ordre séquentiel, et les connecteurs sont utilisés pour joindre des branches de décision ou de boucle.
## Partie 1 : Exercices Très Basiques
### Correction Exercice 1 : Préparer un Café
**Raisonnement :**
Cet exercice est une application directe du concept de séquence. Il s'agit de lister les étapes dans l'ordre logique d'exécution. Chaque action est un "Traitement".
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[Remplir la machine à café avec de l'eau]
B --> C[Mettre du café moulu dans le filtre]
C --> D[Placer la tasse sous le bec verseur]
D --> E[Démarrer la machine à café]
E --> F[Attendre que le café soit prêt]
F --> G([Fin])
```
`
> [!tip] Simplicité
> Pour ce type d'exercice, il n'est pas nécessaire de détailler chaque micro-action. L'objectif est de montrer la capacité à structurer un processus simple.
### Correction Exercice 2 : Somme de Deux Nombres
**Raisonnement :**
Nous avons besoin de deux valeurs en entrée, une opération de calcul, et une valeur en sortie. Cela implique les symboles d'entrée, de traitement et de sortie.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[/Lire Nombre1/]
B --> C[/Lire Nombre2/]
C --> D["Somme = Nombre1 + Nombre2"]
D --> E[/Afficher "La somme est : " + Somme/]
E --> F([Fin])
```
> [!definition] Variable
> Une **variable** est un espace de stockage nommé en mémoire qui peut contenir une valeur. Dans cet exercice, `Nombre1`, `Nombre2` et `Somme` sont des variables.
## Partie 2 : Exercices de Niveau Normal
### Correction Exercice 3 : Vérification de Parité
**Raisonnement :**
La parité d'un nombre se vérifie en testant si le reste de sa division par 2 est 0. C'est une condition `Si...Alors...Sinon`.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[/Lire Nombre/]
B --> C{Nombre % 2 == 0 ?}
C -->|Vrai| D["Message = 'Le nombre est pair.'"]
C -->|Faux| E["Message = 'Le nombre est impair.'"]
D --> F[/Afficher Message/]
E --> F
F --> G([Fin])
```
> [!note] Opérateur Modulo
> L'opérateur modulo, noté `%` ou `mod` selon les langages, renvoie le reste de la division euclidienne. Par exemple, $5 \pmod 2 = 1$ et $4 \pmod 2 = 0$.
### Correction Exercice 4 : Compteur Simple
**Raisonnement :**
Pour afficher les nombres de 1 à $N$, nous avons besoin d'une boucle. Une variable `Compteur` sera initialisée à 1 et incrémentée à chaque itération, tant qu'elle est inférieure ou égale à $N$.
**Algorigramme :**
```mermaid
graph TD
A([Début]) --> B[/Lire N/]
B --> C[Compteur = 1]
C --> D{Compteur ≤ N ?}
D -->|Vrai| E[/Afficher Compteur/]
E --> F[Compteur = Compteur + 1]
F --> D
D -->|Faux| G([Fin])
```
> [!theorem] Structure de Boucle "Tant que"
> Une boucle `Tant que` (ou `While`) exécute un bloc d'instructions *tant qu'une condition est vraie*. La condition est testée *avant* chaque exécution du bloc. Si la condition est fausse dès le départ, le bloc n'est jamais exécuté.
### Correction Exercice 5 : Calcul du Prix TTC avec Remise
**Raisonnement :**
Il y a une condition pour la remise. Le calcul du prix TTC se fera après l'application ou non de cette remise.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[/Lire PrixHT/]
B --> C{PrixHT ≥ 100 ?}
C -->|Oui| D["PrixHT = PrixHT × 0.90"]
C -->|Non| D
D --> E[TauxTVA = 0.20]
E --> F["PrixTTC = PrixHT × (1 + TauxTVA)"]
F --> G[/Afficher PrixTTC/]
G --> H([Fin])
```
> [!example] Tracé avec des valeurs
> - Si `PrixHT = 80` : `PrixHT >= 100` est Faux. `PrixFinalHT` reste 80. `PrixTTC = 80 * 1.20 = 96`.
> - Si `PrixHT = 120` : `PrixHT >= 100` est Vrai. `PrixFinalHT = 120 * 0.90 = 108`. `PrixTTC = 108 * 1.20 = 129.6`.
### Correction Exercice 6 : Somme des N Premiers Entiers
**Raisonnement :**
Nous devons parcourir les nombres de 1 à $N$ et les ajouter successivement à une variable qui accumule la somme.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[/Lire N/]
B --> C[Somme = 0]
C --> D[Compteur = 1]
D --> E{Compteur ≤ N ?}
E -->|Vrai| F["Somme = Somme + Compteur"]
F --> G["Compteur = Compteur + 1"]
G --> E
E -->|Faux| H[/Afficher "La somme des " + N + " premiers entiers est : " + Somme/]
H --> I([Fin])
```
> [!note] Formule alternative
> Pour rappel, la somme des $N$ premiers entiers peut aussi être calculée par la formule mathématique : $S = \frac{N \times (N+1)}{2}$. Un algorigramme utilisant cette formule serait plus efficace pour des $N$ très grands, mais l'exercice visait la pratique des boucles.
## Partie 3 : Exercices Plus Élaborés
### Correction Exercice 7 : Calcul de Factorielle
**Raisonnement :**
Le calcul de la factorielle est un produit itératif. Il faut gérer le cas $N=0$ séparément.
**Algorigramme :**
```mermaid
%%{init: {'flowchart': { 'useMaxWidth': false}}}%%
graph TD
A([Début]) --> B[/Lire N/]
B --> C[Factorielle = 1]
C --> D[Compteur = 1]
D --> E{N < 0 ?}
E -->|Oui| F[/Afficher "Erreur : N doit être ≥ 0"/]
F --> Z([Fin])
E -->|Non| G{N == 0 ?}
G -->|Oui| H[Factorielle = 1]
H --> Y
G -->|Non| I{Compteur ≤ N ?}
I -->|Oui| J["Factorielle = Factorielle × Compteur"]
J --> K["Compteur = Compteur + 1"]
K --> I
I -->|Non| Y
Y --> L[/Afficher "La factorielle de N est : " + Factorielle/]
L --> Z([Fin])
```
> [!warning] Initialisation de la factorielle
> Il est crucial d'initialiser `Factorielle` à 1, et non à 0. En effet, $0! = 1$, et toute multiplication par 0 donnerait un résultat final de 0, ce qui est incorrect.
### Correction Exercice 8 : Racines d'une Équation du Second Degré
**Raisonnement :**
Il faut d'abord calculer le discriminant $\Delta$, puis utiliser des conditions pour déterminer le nombre et la nature des racines.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[/Lire a/]
B --> C[/Lire b/]
C --> D[/Lire c/]
D --> E{a == 0 ?}
%% --- Cas équation du 1er degré ---
E -->|Oui| F{b == 0 ?}
F -->|Oui| G{c == 0 ?}
G -->|Oui| H[/Afficher "Infinité de solutions"/]
G -->|Non| I[/Afficher "Pas de solution"/]
H --> Z([Fin])
I --> Z
F -->|Non| J["x = -c / b"]
J --> K[/Afficher "Solution unique : x"/]
K --> Z
%% --- Cas équation du 2nd degré ---
E -->|Non| L["Delta = b*b - 4*a*c"]
L --> M{Delta > 0 ?}
M -->|Oui| N["x1 = (-b - sqrt(Delta)) / (2*a)"]
N --> O["x2 = (-b + sqrt(Delta)) / (2*a)"]
O --> P[/Afficher "Deux racines : x1, x2"/]
P --> Z
M -->|Non| Q{Delta == 0 ?}
Q -->|Oui| R["x0 = -b / (2*a)"]
R --> S[/Afficher "Racine double : x0"/]
S --> Z
Q -->|Non| T[/Afficher "Pas de racines réelles"/]
T --> Z
Z([Fin])
```
> [!note] Gestion du cas `a=0`
> Il est important de gérer le cas où $a=0$. L'équation devient alors $bx+c=0$, une équation du premier degré. Si de plus $b=0$, c'est $c=0$ (infinité de solutions) ou $c \neq 0$ (pas de solution). Cette gestion montre une robustesse de l'algorithme.
### Correction Exercice 9 : Recherche du Maximum
**Raisonnement :**
Nous utilisons une boucle `Tant que` qui continue tant que l'utilisateur n'entre pas 0. À chaque itération, nous comparons le nombre saisi au maximum actuel et mettons à jour si nécessaire. Il faut gérer le cas où aucun nombre valide n'est saisi.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[Max = -1]
B --> C[NbSaisis = 0]
C --> D[/Lire Nombre/]
D --> E{Nombre != 0 ?}
%% Si Nombre ≠ 0
E -->|Oui| F[NbSaisis = NbSaisis + 1]
F --> G{Nombre > Max ?}
G -->|Oui| H[Max = Nombre]
G -->|Non| I[Max inchangé]
H --> D
I --> D
%% Si Nombre = 0 : sortie de boucle
E -->|Non| J{NbSaisis == 0 ?}
J -->|Oui| K[/Afficher "Aucun nombre valide saisi"/]
J -->|Non| L[/Afficher "Max = " + Max/]
K --> M([Fin])
L --> M([Fin])
```
> [!tip] Initialisation du maximum
> Pour trouver le maximum d'une série de nombres positifs, une bonne pratique est d'initialiser `Max` avec la première valeur saisie, ou avec une valeur suffisamment petite pour être dépassée par n'importe quel nombre valide. Ici, -1 fonctionne car les nombres sont positifs.
### Correction Exercice 10 : Simulation de Retrait Bancaire
**Raisonnement :**
Il y a trois conditions à vérifier pour valider un retrait. Nous pouvons les vérifier séquentiellement et afficher un message d'erreur dès qu'une condition n'est pas remplie, ou vérifier toutes les conditions et n'autoriser le retrait que si toutes sont vraies. La deuxième approche est plus claire pour l'utilisateur car elle peut lister toutes les erreurs.
**Algorigramme :**
```mermaid
graph TB
A([Début]) --> B[/Lire SoldeInitial/]
B --> C[/Lire MontantRetrait/]
C --> D[RetraitValide = Vrai]
%% Test montant > 0
D --> E{MontantRetrait <= 0 ?}
E -->|Oui| F[/Afficher "Erreur : montant doit être > 0"/]
F --> G[RetraitValide = Faux]
E -->|Non| H[OK]
%% Test multiple de 10
G --> I{MontantRetrait % 10 != 0 ?}
H --> I
I -->|Oui| J[/Afficher "Erreur : montant doit être multiple de 10"/]
J --> K[RetraitValide = Faux]
I -->|Non| L[OK]
%% Test solde suffisant
K --> M{MontantRetrait > SoldeInitial ?}
L --> M
M -->|Oui| N[/Afficher "Erreur : solde insuffisant"/]
N --> O[RetraitValide = Faux]
M -->|Non| P[OK]
%% Décision finale
O --> Q{RetraitValide == Vrai ?}
P --> Q
Q -->|Vrai| R["NouveauSolde = SoldeInitial - MontantRetrait"]
R --> S[/Afficher "Retrait effectué"/]
S --> T[/Afficher "Nouveau solde = " + NouveauSolde/]
T --> U([Fin])
Q -->|Faux| V[/Afficher "Retrait refusé : erreurs ci-dessus"/]
V --> U([Fin])
```
> [!note] Approche avec variable booléenne
> L'utilisation d'une variable `RetraitValide` (booléenne) permet de vérifier toutes les conditions avant de prendre la décision finale d'effectuer ou non le retrait. Cela permet d'afficher toutes les erreurs pertinentes à l'utilisateur, plutôt que de s'arrêter à la première erreur rencontrée.
---
## Conclusion
Félicitations ! En ayant parcouru et compris ces exercices, vous avez considérablement renforcé vos compétences en algorigrammes. Vous êtes désormais capable de :
- Traduire des problèmes simples en séquences d'opérations.
- Utiliser les structures conditionnelles pour gérer des choix.
- Mettre en œuvre des boucles pour des opérations répétitives.
- Combiner ces structures pour résoudre des problèmes plus complexes.
Cette maîtrise des algorigrammes est une étape cruciale. Elle vous a permis de développer une pensée algorithmique structurée, essentielle pour les prochaines étapes de votre formation en programmation. La capacité à modéliser un problème avant de le coder est une qualité d'ingénieur indispensable. Vous êtes maintenant bien préparés pour aborder les concepts d'algorithmique et les premiers pas en SQL, où la logique que vous avez développée ici sera directement applicable.
> [!tip] Prochaines Étapes
> Pour aller plus loin, essayez de concevoir des algorigrammes pour des problèmes de votre quotidien ou des défis logiques que vous rencontrez. La pratique régulière est la clé de la maîtrise !
# 🗓️ Historique
> **Dernière mise à jour :** `01 novembre 2025`
> **Rédigé par :** [[Julien DUQUENNOY]]