Après avoir analysé un problème, il faut maintenant écrire sa solution sous une forme structurée : l’algorithme. Cette partie vous présente le squelette d’un algorithme, puis les trois seuls types de traitements dont vous avez besoin pour résoudre n’importe quel problème.
- Connaître les deux grandes parties d’un algorithme : déclarations et traitements.
- Écrire un algorithme en pseudo-code.
- Utiliser le traitement séquentiel (les instructions dans l’ordre).
- Utiliser le traitement alternatif (si / sinon).
- Utiliser le traitement itératif (répéter des instructions).
La structure d’un algorithme
Un algorithme suit toujours la même structure en deux grandes parties : d’abord on déclare ce dont on va avoir besoin, puis on écrit les traitements qui transforment les données en résultat.
Variable : un espace nommé qui contient une valeur pouvant changer pendant l’exécution de l’algorithme (un nombre, un texte…). Constante : un espace nommé dont la valeur ne change jamais.
Le programme officiel recommande d’écrire les algorithmes dans un pseudo-code : un langage simplifié, proche du français, qui ne dépend d’aucun langage de programmation précis. Voici la structure que nous utiliserons tout au long du module :
Algorithme nom_de_l_algorithme
Variables
nom_variable : type
Début
instruction 1
instruction 2
…
Fin
| Type de donnée | Exemple de valeur |
|---|---|
| Entier | 5, -12, 1000 |
| Réel (décimal) | 12.5, 3.14 |
| Chaîne de caractères | "Fatima", "DD-M102" |
| Booléen | Vrai, Faux |
moyenne ← somme / nombre).
Le traitement séquentiel
C’est le traitement le plus simple : les instructions s’exécutent les unes après les autres, dans l’ordre où elles sont écrites, sans retour en arrière ni choix. C’est la base de tout algorithme.
Algorithme moyenne_deux_notes
Variables note1, note2, moyenne : réel
Début
Lire(note1)
Lire(note2)
moyenne ← (note1 + note2) / 2
Écrire(moyenne)
Fin
Changer l’ordre de ces instructions change le résultat, voire empêche l’algorithme de fonctionner : on ne peut pas calculer la moyenne avant d’avoir lu les deux notes.
Le traitement alternatif
Un traitement alternatif permet de choisir entre plusieurs chemins possibles, selon une condition. On l’écrit avec Si … Alors … Sinon.
Condition : une expression qui s’évalue à Vrai ou à Faux
(par exemple moyenne >= 10), et qui détermine quel bloc
d’instructions s’exécute.
Algorithme verifier_reussite
Variables moyenne : réel
Début
Lire(moyenne)
Si moyenne >= 10 Alors
Écrire("Module validé")
Sinon
Écrire("Module à repasser")
FinSi
Fin
On peut enchaîner plusieurs conditions avec SinonSi, pour gérer plus de deux cas :
Si moyenne >= 16 Alors
Écrire("Mention Très Bien")
SinonSi moyenne >= 14 Alors
Écrire("Mention Bien")
SinonSi moyenne >= 10 Alors
Écrire("Mention Passable")
Sinon
Écrire("Non validé")
FinSi
=,
≠, <, >, <=,
>=) et peuvent se combiner avec ET,
OU et NON, par exemple
age >= 18 ET niveau = "avancé".
Le traitement itératif
Un traitement itératif, ou boucle, permet de répéter un bloc d’instructions sans avoir à le réécrire plusieurs fois. Le programme officiel distingue deux grandes familles de boucles.
Répéter un nombre connu de fois : Pour
Algorithme afficher_table
Variables i : entier
Début
Pour i ← 1 à 10
Écrire(i * 5)
FinPour
Fin
Cet algorithme affiche la table de 5, de 5×1 à 5×10 : la boucle Pour connaît à l’avance son nombre de répétitions (ici, 10).
Répéter tant qu’une condition est vraie : TantQue
Algorithme somme_jusqu_a_100
Variables somme, nombre : entier
Début
somme ← 0
nombre ← 0
TantQue somme < 100
nombre ← nombre + 1
somme ← somme + nombre
FinTantQue
Écrire(nombre)
Fin
Ici, on ne sait pas à l’avance combien de tours seront nécessaires : la boucle TantQue continue tant que sa condition reste vraie, et s’arrête dès qu’elle devient fausse.
| Boucle | À utiliser quand… |
|---|---|
| Pour | Le nombre de répétitions est connu à l’avance |
| TantQue | On répète jusqu’à ce qu’une condition change, sans connaître le nombre exact de tours |
- Un algorithme se compose de déclarations (variables, constantes) puis de traitements.
- Le traitement séquentiel exécute les instructions dans l’ordre d’écriture.
- Le traitement alternatif (Si / Sinon / SinonSi) choisit un chemin selon une condition.
- Le traitement itératif répète un bloc : Pour pour un nombre connu de répétitions, TantQue pour une condition.
- Une boucle TantQue doit toujours faire évoluer la condition testée, sinon elle ne s’arrête jamais.
Vérifiez vos acquis
Quelles sont les deux grandes parties d’un algorithme ?
Les déclarations (variables, constantes) et les traitements.
Quand utiliser une boucle Pour plutôt qu’une boucle TantQue ?
Quand le nombre de répétitions est connu à l’avance.
Que risque-t-on si on oublie de faire évoluer la condition d’une boucle TantQue ?
Une boucle infinie : l’algorithme ne s’arrête jamais.
Exercices corrigés
Exercice 1 — Écrivez un algorithme qui lit l’âge d’une personne et écrit « Majeur » si elle a 18 ans ou plus, « Mineur » sinon.
Algorithme verifier_majorite
Variables
age : entier
Début
Lire(age)
Si age
>= 18 Alors
Écrire("Majeur")
Sinon
Écrire("Mineur")
FinSi
Fin
Exercice 2 — Écrivez un algorithme qui affiche les nombres pairs de 1 à 20 à l’aide d’une boucle Pour.
Algorithme nombres_pairs
Variables
i : entier
Début
Pour
i ← 1 à 20
Si
i modulo 2 = 0 Alors
Écrire(i)
FinSi
FinPour
Fin
Exercice 3 — Pourquoi utilise-t-on une boucle TantQue plutôt qu’une boucle Pour pour demander un mot de passe jusqu’à ce qu’il soit correct ?
Parce qu’on ne sait pas à l’avance combien de tentatives seront nécessaires : la boucle doit continuer tant que la condition « mot de passe incorrect » reste vraie.
Exercice 4 — Que calcule cet algorithme ?
somme ← 0 ; Pour i ← 1 à 5 ; somme ← somme + i ; FinPour ;
Écrire(somme)
Il calcule la somme des entiers de 1 à 5, soit 1+2+3+4+5 = 15.
Vous savez maintenant construire la logique d’un algorithme. Dans la partie suivante, vous apprenez à organiser votre code avec des fonctions, puis à manipuler des chaînes de caractères et des tableaux.
Commentaires
Enregistrer un commentaire