Office de la formation professionnelle · ressources stagiaires● Cours · Exercices · Examens corrigés

M102 – Partie 2 : Construire un algorithme | Développement Digital​

novembre 19, 2026 · OF-PPT

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
Les instructions de base sont : Lire (recevoir une donnée), Écrire (afficher un résultat) et ← (affecter une valeur à une variable, par exemple 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

Les conditions utilisent des opérateurs de comparaison (=, ≠, <, >, <=, >=) 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
Une erreur fréquente des débutants : oublier de modifier la variable testée dans la condition d’une boucle TantQue. Si « nombre » n’augmentait jamais dans l’exemple ci-dessus, la boucle ne s’arrêterait jamais — on parle de « boucle infinie ».
  • 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

Formulaire de contact

Nom

E-mail *

Message *