Support de Cours : Notions d’Algorithmique

Rachid MENAOUI

March 18, 2026

Contents

1 Introduction à l’Algorithmique 3
1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Exemples de la vie courante : Comprendre par l’analogie . . . . . . . . . . . . 3
1.2.1 La Recette de cuisine : L’analogie du traitement . . . . . . . . . . . . . 3
1.2.2 L’appareil téléphonique : L’analogie de la séquence . . . . . . . . . . . 3
1.2.3 Le Distributeur automatique (Enrichissement) . . . . . . . . . . . . . . 3
1.3 Conclusion de l’analogie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Les Variables et Types de Données 4

2.1 Les Types de base (Détails) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Règles d’écriture des noms de variables (Identificateurs) . . . . . . . . . . . . 5
2.3 L’Affectation : Le transfert de donnée . . . . . . . . . . . . . . . . . . . . . . . 5
2.4 Bonnes pratiques de nommage (Enrichissement) . . . . . . . . . . . . . . . . 5

3 Instructions de Base : Les Entrées et Sorties 5

3.1 L’Écriture (La Sortie) : Ecrire . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 La Lecture (L’Entrée) : Lire . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Analyse détaillée de l’algorithme SommeDeuxNombres . . . . . . . . . . . . . . 6
3.4 Bonnes pratiques pour les interfaces homme-machine (IHM) . . . . . . . . . . 7

4 Les Instructions de Contrôle (La Sélection) 7

4.1 La structure SI . . . ALORS . . . SINON . . . . . . . . . . . . . . . . . . . . . . . 7
4.1.1 Syntaxe et Logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.1.2 La notion de "Condition" (Expressions Booléennes) . . . . . . . . . . . 7
4.2 Les différentes formes de sélection . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.1 La forme simple (Si . . . Alors) . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.2 La forme complète (Si . . . Alors . . . Sinon) . . . . . . . . . . . . . . . 8
4.2.3 Les structures imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2.4 Le Branchement Conditionnel : SELON (Choix Multiple) . . . . . . . . 8
4.2.5 Pourquoi utiliser "Selon" ? . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2.6 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.2.7 Exemple d’algorithme : Menu de calculatrice . . . . . . . . . . . . . . 9

5 Les Instructions de Répétition (Les Boucles) 9

5.1 La boucle POUR (Nombre d’itérations connu) . . . . . . . . . . . . . . . . . . 10
5.1.1 Fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.1.2 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1
 5.1.3 Exemple détaillé : Table de Multiplication . . . . . . . . . . . . . . . . 10
5.2 La boucle TANT QUE (Condition de sortie) . . . . . . . . . . . . . . . . . . . . 10
5.2.1 Fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.2.2 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
5.2.3 Exemple : Contrôle de saisie . . . . . . . . . . . . . . . . . . . . . . . . 11
5.3 La boucle RÉPÉTER . . . JUSQU’À (Variante) . . . . . . . . . . . . . . . . . . . 11
5.4 Comment choisir sa boucle ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5.4.1 Erreur classique : La boucle infinie . . . . . . . . . . . . . . . . . . . . 11

2 Rachid MENAOUI
1 Introduction à l'Algorithmique

1.1 Dénition
Un algorithme est une suite finie d’actions à appliquer dans un ordre déterminé sur des
données afin d’obtenir un résultat en un temps fini.

1.2 Exemples de la vie courante : Comprendre par l'analogie

L’algorithmique n’est pas réservée à l’informatique ; c’est une méthode de résolution de prob-
lèmes que nous appliquons inconsciemment chaque jour. Ces exemples illustrent les trois
piliers d’un processus : Entrées -> Traitement -> Sortie.

1.2.1 La Recette de cuisine : L’analogie du traitement

Une recette est l’exemple le plus proche d’un programme informatique. Elle suit une séquence
logique où l’ordre des instructions est critique.
• Les Ingrédients (Données d’entrée) : Ce sont les variables nécessaires (œufs, farine,
lait). Ils ont des types (entier pour les œufs, réel pour le poids de la farine).
• La Recette (L’Algorithme) : Une suite d’instructions impératives ("Mélanger", "Cuire
10 minutes").
– Structure de contrôle : "Si la pâte est trop épaisse, Alors ajouter du lait".
– Boucle : "Battre les œufs Jusqu’à ce que le mélange blanchisse".
• Le Plat (Résultat) : La donnée de sortie transformée.

1.2.2 L’appareil téléphonique : L’analogie de la séquence

Cet exemple classique montre qu’un algorithme est une suite d’états. Si une étape est sautée
ou inversée, le résultat (la communication) échoue.
• Séquence d’actions :
1. Décrocher : Initialisation du système.
2. Insérer monnaie : Condition de validation (Si crédit > 0 Alors autoriser numéro-
tation).
3. Composer : Saisie de la donnée (Entrée utilisateur).
4. Parler : Corps du programme (Exécution de la tâche principale).
5. Raccrocher : Terminaison du processus et libération des ressources.

1.2.3 Le Distributeur automatique (Enrichissement)

Un autre exemple très parlant pour les ingénieurs est le distributeur de boissons :
1. Attente : L’algorithme tourne en boucle tant qu’aucune pièce n’est insérée.
2. Saisie : L’utilisateur choisit un code (A1, B2).
3. Test : Le système vérifie si le stock est suffisant ET si le montant inséré est correct.

3 Rachid MENAOUI
 4. Action : Libération du produit et rendu de la monnaie.

1.3 Conclusion de l'analogie

Ces exemples nous apprennent trois règles d’or de l’algorithmique :
1. L’ordre compte : On ne peut pas raccrocher avant d’avoir décroché.
2. La précision : "Ajouter du sel" est vague, "Ajouter 5 grammes de sel" est algorithmique.
3. L’exhaustivité : L’algorithme doit prévoir tous les cas (ex: que faire si l’interlocuteur
ne décroche pas ?).

2 Les Variables et Types de Données

Une variable peut être comparée à une boîte étiquetée rangée dans la mémoire de l’ordinateur.
Pour utiliser cette "boîte", l’algorithme a besoin de trois informations : son nom (l’étiquette),
son type (la forme de la boîte) et sa valeur (le contenu).

2.1 Les Types de base (Détails)

Le type détermine la nature des opérations permises sur la variable.
1. Entier (Integer) :
• Utilisation : Compteurs, nombres de personnes, index.
• Exemple : ‘10‘, ‘-5‘, ‘0‘.
2. Réel (Float/Real) :
• Utilisation : Mesures physiques, prix, moyennes.
• Exemple : ‘15.5‘, ‘3.14159‘, ‘-0.001‘.
3. Chaîne de caractères (String) :
• Utilisation : Noms, adresses, messages.
• Syntaxe : Toujours délimitée par des guillemets ‘" "‘.
• Exemple : ‘"Bonjour"‘, ‘"ENSAM 2025"‘.
4. Caractère (Char) :
• Un seul symbole (lettre, chiffre ou ponctuation).
• Exemple : ‘’A’‘, ‘’@’‘, ‘’7’‘.
5. Booléen (Boolean) :
• Utilisation : Tests logiques et conditions.
• Valeurs possibles : ‘Vrai‘ ou ‘Faux‘.

4 Rachid MENAOUI
2.2 Règles d'écriture des noms de variables (Identicateurs)
Pour que l’algorithme soit lisible et accepté par les compilateurs, le nom d’une variable doit
respecter des règles strictes :
1. Composition : Uniquement des lettres (A-Z, a-z), des chiffres (0-9) et le caractère de
soulignement ‘_‘ (underscore).
2. Premier caractère : Le nom doit obligatoirement commencer par une lettre (jamais
par un chiffre).
3. Pas d’espaces : "Ma Variable" est interdit. Utilisez "MaVariable" ou "ma_variable".
4. Pas de caractères spéciaux : Évitez les accents (‘é‘, ‘à‘), les tirets ‘-‘, et la ponctuation.
5. Mots réservés : On ne peut pas nommer une variable ‘Si‘, ‘Alors‘ ou ‘Algorithme‘ car ce
sont des mots clés du langage.
6. La casse : En général, les noms sont sensibles à la casse (‘Somme‘ est différent de
‘somme‘).

2.3 L'Aectation : Le transfert de donnée

L’opération d’affectation est l’action de placer une valeur dans une variable.
• Symbole : On utilise la flèche ‘<-‘ (ou ‘=‘ dans certains langages) qui se lit "reçoit".
• Sens : Le transfert se fait toujours de la droite vers la gauche.
• Écrasement : Lorsqu’on affecte une nouvelle valeur, l’ancienne est définitivement per-
due.
Exemple :
A <- 10 ; // A contient 10
B <- 5 ; // B contient 5
A <- A + B ; // A reçoit (10 + 5), donc A contient maintenant 15. L'ancien 10 est effa

2.4 Bonnes pratiques de nommage (Enrichissement)

• Nom explicite : Préférez ‘RayonCercle‘ à ‘R1‘ ou ‘X‘. Un bon nom indique immédiate-
ment ce que contient la variable.
• Convention CamelCase : Commencer chaque mot par une majuscule sauf éventuelle-
ment le premier (ex: ‘prixTotalTTC‘).
• Convention SnakeCase : Séparer les mots par des underscores (ex: prix_total_ttc).

3 Instructions de Base : Les Entrées et Sorties

Pour qu’un algorithme puisse interagir avec le monde extérieur, il utilise deux types d’instructions
fondamentales : les sorties (pour communiquer des résultats) et les entrées (pour récupérer
des données).

5 Rachid MENAOUI
3.1 L'Écriture (La Sortie) : Ecrire
L’instruction Ecrire (ou Afficher) permet de transmettre des informations de l’ordinateur
vers l’utilisateur (généralement sur l’écran).
• Afficher du texte : On place le message entre guillemets.
– Exemple : Ecrire("Bienvenue à l'ENSAM")
• Afficher la valeur d’une variable : On écrit le nom de la variable sans guillemets.
– Exemple : Ecrire(S) (affiche la valeur contenue dans S).
• Afficher un mélange (Concaténation) : On sépare les textes et les variables par des
virgules.
– Exemple : Ecrire("Le résultat est : ", R)

3.2 La Lecture (L'Entrée) : Lire

L’instruction Lire (ou Saisir) permet à l’utilisateur de fournir une valeur à l’algorithme via
le clavier.
• Fonctionnement : L’algorithme s’interrompt et attend que l’utilisateur tape une valeur
et appuie sur "Entrée".
• Stockage : La valeur saisie est immédiatement rangée dans la variable spécifiée.
• Attention : La variable doit avoir été déclarée au préalable avec un type compatible
avec ce que l’utilisateur va saisir.

3.3 Analyse détaillée de l'algorithme SommeDeuxNombres

Voici comment l’interaction se déroule étape par étape :
Algorithme SommeDeuxNombres
Variables:
A, B, S : Entier
Début
// 1. On affiche une consigne (Sortie)
Ecrire("Donner le premier nombre :");

// 2. Le programme s'arrête et attend la saisie (Entrée)

Lire(A) ;

// 3. Nouvelle consigne (Sortie)

Ecrire("Donner le deuxième nombre :");

// 4. Deuxième saisie (Entrée)

Lire(B) ;

// 5. Calcul interne (Traitement)

S <- A + B ;

// 6. Affichage du résultat final (Sortie combinée)

6 Rachid MENAOUI
 Ecrire("La somme est : ", S);
Fin

3.4 Bonnes pratiques pour les interfaces homme-machine (IHM)

1. Toujours précéder un Lire par un Ecrire : Si vous utilisez Lire(A) sans expliquer ce
que vous attendez, l’utilisateur verra un curseur clignoter sans savoir quoi faire. C’est
ce qu’on appelle une invite (prompt).
2. Clarté du résultat : Préférez Ecrire("La température est de : ", T, " degrés")
à un simple Ecrire(T) qui affiche un chiffre brut difficile à interpréter.

4 Les Instructions de Contrôle (La Sélection)

Dans un algorithme, les instructions ne s’exécutent pas toujours de manière linéaire. Les
instructions de contrôle permettent de rompre cette linéarité en prenant des décisions. La
structure la plus fondamentale est la sélection (ou structure conditionnelle).

4.1 La structure SI . . . ALORS . . . SINON

Cette structure permet de n’exécuter un bloc d’instructions que si une condition spécifique
est remplie. Si la condition n’est pas remplie, l’algorithme peut soit ne rien faire, soit exécuter
un autre bloc d’instructions (le "Sinon").

4.1.1 Syntaxe et Logique

Si condition Alors
// Bloc d'instructions exécuté si la condition est VRAIE
Sinon
// Bloc d'instructions exécuté si la condition est FAUSSE (Optionnel)
FinSi

4.1.2 La notion de "Condition" (Expressions Booléennes)

Une condition est une expression dont le résultat est soit Vrai, soit Faux. Elle utilise générale-
ment :
• Des opérateurs de comparaison : - ‘=‘ (égal), ‘<>‘ (différent)
– ‘<‘ (inférieur), ‘>‘ (supérieur)
– ‘<=‘ (inférieur ou égal), ‘>=‘ (supérieur ou égal)
• Des opérateurs logiques : - ‘ET‘ (toutes les conditions doivent être vraies)
– ‘OU‘ (au moins une condition doit être vraie)
– ‘NON‘ (inverse l’état de la condition)

7 Rachid MENAOUI
4.2 Les diérentes formes de sélection
4.2.1 La forme simple (Si . . . Alors)
On l’utilise quand on ne veut agir que si la condition est vraie. Exemple : Si un article est en
promotion, on applique une remise.

4.2.2 La forme complète (Si . . . Alors . . . Sinon)

On l’utilise quand on a deux alternatives exclusives. Exemple :
Si (Moyenne >= 10) Alors
Ecrire("Admis");
Sinon
Ecrire("Ajourné");
FinSi

4.2.3 Les structures imbriquées

On peut placer un ‘Si‘ à l’intérieur d’un autre ‘Si‘ pour tester plusieurs conditions successives.
Exemple d’algorithme : Comparaison de deux nombres
Algorithme Comparaison
Variables:
A, B : Entier
Début
Ecrire("Entrez deux nombres :");
Lire(A, B);
Si (A > B) Alors
Ecrire(A, " est plus grand que ", B);
Sinon
Si (A < B) Alors
Ecrire(A, " est plus petit que ", B);
Sinon
Ecrire("Les deux nombres sont égaux");
FinSi
FinSi
Fin
1. Analyse de l’exécution ( SI SINON)
(a) L’ordinateur évalue la condition (ex: ‘A > B‘).
(b) Si le résultat est Vrai, il entre dans le bloc "Alors" et ignore totalement le bloc
"Sinon".
(c) Si le résultat est Faux, il saute le bloc "Alors" et exécute le bloc "Sinon" (s’il existe).
(d) Dans tous les cas, l’algorithme reprend son cours normal après le ‘FinSi‘.

4.2.4 Le Branchement Conditionnel : SELON (Choix Multiple)

La structure Selon (aussi appelée Cas par cas ou Switch) est une alternative élégante aux
structures ‘Si . . . SinonSi‘ imbriquées lorsque l’on doit tester plusieurs valeurs possibles pour

8 Rachid MENAOUI
une même variable.

4.2.5 Pourquoi utiliser "Selon" ?

Elle rend l’algorithme beaucoup plus lisible quand on a un grand nombre de choix basés sur
une seule variable (comme un menu ou les jours de la semaine).

4.2.6 Syntaxe
Selon variable Faire
Valeur_1 : Instructions bloc 1
Valeur_2 : Instructions bloc 2
...
Sinon :
Instructions si aucune valeur ne correspond
FinSelon

4.2.7 Exemple d’algorithme : Menu de calculatrice

Algorithme MenuCalcul
Variables:
choix : Entier
Début
Ecrire("1: Addition, 2: Soustraction, 3: Quitter");
Lire(choix);
Selon choix Faire
1 : Ecrire("Exécution de l'addition");
2 : Ecrire("Exécution de la soustraction");
3 : Ecrire("Au revoir");
Sinon :
Ecrire("Erreur : Choix invalide");
FinSelon
Fin
1. Analyse de l’exécution (Selon)
(a) Évaluation : L’ordinateur évalue la valeur de la variable ou de l’expression.
(b) Saut : Il "saute" directement au cas (Valeur) correspondant.
(c) Exclusion : Une fois qu’un cas est exécuté, il sort de la structure et ne teste pas les
autres.
(d) Sécurité : Le bloc ‘Sinon‘ (ou ‘Autrement‘) permet de gérer les imprévus (erreurs
de saisie de l’utilisateur).

5 Les Instructions de Répétition (Les Boucles)

En algorithmique, une boucle (ou itération) est une structure qui permet de répéter l’exécution
d’un bloc d’instructions tant qu’une condition donnée est réalisée. Cela évite la duplication
de code et permet de traiter des volumes de données importants.

9 Rachid MENAOUI
5.1 La boucle POUR (Nombre d'itérations connu)
On utilise la boucle Pour (ou boucle bornée) lorsque l’on connaît à l’avance le nombre de
répétitions à effectuer.

5.1.1 Fonctionnement
Elle utilise une variable de contrôle (souvent appelée ‘i‘ pour index) qui progresse d’une
valeur initiale à une valeur finale selon un pas donné (par défaut +1).

5.1.2 Syntaxe
Pour compteur <- valeur_initiale à valeur_finale [pas de n] Faire
Instructions à répéter
FinPour

5.1.3 Exemple détaillé : Table de Multiplication

Cet algorithme affiche les 10 premières lignes de la table d’un nombre choisi.
Algorithme TableDeMultiplication
Variables:
n, i : entier
Début
Ecrire("Donner n :");
Lire(n);
// La boucle va s'exécuter exactement 10 fois
Pour i <- 1 à 10 faire
Ecrire(n, " * ", i, " = ", n*i);
FinPour
Fin

5.2 La boucle TANT QUE (Condition de sortie)

La boucle Tant Que (ou boucle non bornée) est utilisée lorsque le nombre de répétitions n’est
pas connu à l’avance. L’exécution dépend d’une condition logique qui doit être vraie pour que
la boucle continue.

5.2.1 Fonctionnement
1. L’algorithme teste la condition.
2. Si elle est Vraie, il exécute le bloc d’instructions, puis remonte tester la condition.
3. Si elle est Fausse, il sort de la boucle et continue la suite de l’algorithme.

5.2.2 Syntaxe
Tant Que (condition) Faire
Instructions
FinTantQue

10 Rachid MENAOUI
5.2.3 Exemple : Contrôle de saisie
Algorithme SaisieNote
Variables:
note : réel
Début
Ecrire("Entrez une note (entre 0 et 20) :");
Lire(note);

// On répète tant que la note est invalide

Tant Que (note < 0 OU note > 20) Faire
Ecrire("Erreur ! Recommencez :");
Lire(note);
FinTantQue

Ecrire("Note valide enregistrée : ", note);

Fin

5.3 La boucle RÉPÉTER . . . JUSQU'À (Variante)

Contrairement au "Tant Que", cette boucle exécute le bloc d’instructions au moins une fois
avant de tester la condition de sortie.
Répéter
Instructions
Jusqu'à (condition de sortie soit vraie)

5.4 Comment choisir sa boucle ?

• Pour : Quand le nombre de tours est fixe et connu (ex: parcourir les 12 mois de
l’année).
• Tant Que : Quand on ne sait pas quand l’événement va se produire (ex: lire un fichier
jusqu’à la fin, attendre que l’utilisateur tape "Quitter").
• Répéter : Quand on veut que l’action se produise au moins une fois (ex: demander un
mot de passe).

5.4.1 Erreur classique : La boucle infinie

Il est impératif que les instructions à l’intérieur d’une boucle Tant Que modifient les variables
de la condition. Sinon, la condition reste vraie indéfiniment et le programme "plante" (boucle
infinie).

11 Rachid MENAOUI