Un algorithme est une suite finie d'instructions précises qui transforme des données d'entrée en un résultat. Rien de plus. Pas besoin d'ordinateur : une recette de cuisine, un mode d'emploi de montage, la méthode de la division posée apprise en primaire — ce sont des algorithmes.

Ce qui distingue l'algorithmique d'un simple mode d'emploi, c'est l'exigence de rigueur. Un humain comble les trous d'une consigne floue ; une machine, non.

Les trois exigences

Pour mériter le nom d'algorithme, une méthode doit satisfaire trois conditions. Elles paraissent évidentes tant qu'on ne cherche pas de contre-exemple.

Fini. L'exécution doit s'arrêter, en un nombre d'étapes borné. « Ajouter 1 à un compteur et recommencer » n'est pas un algorithme : ça ne finit jamais.

Précis. Chaque instruction n'admet qu'une seule interprétation. « Assaisonner à votre goût » est une consigne humaine acceptable et une instruction algorithmique nulle : deux exécutants obtiendraient deux résultats différents.

Effectif. Chaque instruction doit être réellement exécutable avec les moyens disponibles. « Prendre le plus petit nombre réel strictement positif » est parfaitement précis, parfaitement fini à énoncer… et impossible à exécuter, car ce nombre n'existe pas.

Entrée, traitement, sortie

Tout algorithme se lit sur trois temps, et c'est le premier réflexe à acquérir : avant d'écrire une ligne, savoir ce qui entre, ce qu'on en fait, ce qui sort.

Un algorithme n'invente rien : s'il a besoin de la longueur d'un rectangle, quelqu'un doit la lui fournir. Et s'il ne fait rien sortir, il ne sert à rien — un calcul dont personne ne voit le résultat est du travail perdu.

La structure d'un algorithme

Le pseudocode n'est pas un langage de programmation. C'est une convention d'écriture, à mi-chemin entre le français et le code, qui permet de raisonner sans se battre avec la syntaxe d'un langage particulier. Le même algorithme se traduira ensuite en Python, en C ou en JavaScript.

1Algorithme Rectangle2Variables3    longueur, largeur : réels4    aire, perimetre : réels5Début6    Lire(longueur)7    Lire(largeur)8    aire ← longueur × largeur9    perimetre ← 2 × (longueur + largeur)10    Écrire(aire)11    Écrire(perimetre)12Fin

Quatre parties, toujours dans cet ordre : un nom, la déclaration des variables avec leur type, puis le corps entre Début et Fin. Déclarer une variable, c'est réserver un casier en mémoire et annoncer ce qu'on va y mettre.

L'affectation

La flèche ← est le symbole le plus important de tout le cours. aire ← longueur × largeur se lit : calculer ce qui est à droite, puis ranger le résultat dans le casier de gauche.

Elle n'est pas symétrique. aire ← 21 a un sens ; 21 ← aire n'en a aucun. Et elle n'est pas l'égalité mathématique : nous verrons à la leçon suivante que x ← x + 1, absurde en mathématiques, est parfaitement ordinaire en algorithmique.

Suivre une trace d'exécution

Tracer un algorithme, c'est jouer le rôle de la machine : dérouler les lignes une par une en notant, après chaque ligne, le contenu de chaque variable. C'est l'exercice fondamental du semestre — et le seul moyen fiable de trouver pourquoi un algorithme ne fait pas ce qu'on croyait.

Faites défiler l'animation, ou cliquez directement une étape pour y sauter.

Trois choses à remarquer dans cette trace. Les variables commencent à ? : déclarée n'est pas initialisée, et lire une variable jamais affectée est une erreur classique. Écrire ne modifie rien en mémoire — afficher et calculer sont deux actions distinctes. Enfin, le nombre d'étapes était connu d'avance : huit lignes, huit étapes, aucune répétition.

Voici la même trace telle que vous l'écririez sur une copie :

À vous

// Traduisez l'algorithme Rectangle en JavaScript.
// Les Lire() sont remplacés par des valeurs fixées : ce n'est pas la saisie
// qu'on travaille ici, c'est le traitement.
const longueur = 7;
const largeur = 3;

let aire = 0;       // à corriger
let perimetre = 0;  // à corriger

console.log(aire);       // attendu : 21
console.log(perimetre);  // attendu : 20

const longueur = 7;
const largeur = 3;

// La flèche ← du pseudocode devient = en JavaScript : même sens de lecture,
// on calcule la droite et on range le résultat à gauche.
const aire = longueur * largeur;
const perimetre = 2 * (longueur + largeur);

console.log(aire);       // 21
console.log(perimetre);  // 20

À retenir

Une variable est un casier nommé dans la mémoire. Le nom sert à le désigner, le casier contient une valeur, et cette valeur peut changer au cours de l'exécution — d'où le nom.

Trois choses à ne jamais confondre : le nom (somme), le contenu (42), et le type (entier). Le nom ne change jamais. Le contenu change à chaque affectation. Le type est fixé à la déclaration et engage tout le reste.

1Variables2    age : entier3    taille : réel4    nom : chaîne5    majeur : booléen

Un casier peut être vide au départ : déclarer réserve la place, cela ne met rien dedans. Utiliser une variable jamais affectée, c'est lire un casier dont on ne sait pas ce qu'il contient — une des sources d'erreur les plus pénibles à diagnostiquer, parce que le programme ne plante pas forcément, il donne juste un résultat faux.

L'affectation est un remplacement, pas une équation

x ← 5 ne signifie pas « x égale 5 » mais « mets 5 dans x ». La nuance est décisive :

1x ← 52x ← 8

Après ces deux lignes, x vaut 8. Le 5 n'est plus nulle part. L'affectation écrase : elle ne cohabite pas avec l'ancienne valeur, elle la détruit. Un casier ne contient qu'une chose à la fois.

C'est ce qui rend possible une ligne comme celle-ci, qui n'a aucun sens en mathématiques :

1x ← x + 1

Appliquez la règle de la leçon 1 — la droite d'abord. Si x vaut 7 : on évalue 7 + 1, ce qui donne 8, puis on range 8 dans x. La ligne se lit « augmente x de 1 ». Sans la règle de la droite d'abord, elle ressemble à l'équation absurde $x = x + 1$ ; avec elle, elle est limpide.

Échanger deux variables

Voici le problème le plus instructif de toute la leçon. On a a = 5 et b = 9, on veut finir avec a = 9 et b = 5. La solution qui vient naturellement est fausse — et la raison de son échec est exactement la propriété d'écrasement qu'on vient de voir.

Regardez bien l'étape 3. Au moment où a ← b s'exécute, la valeur 5 disparaît de la mémoire. Elle n'est nulle part ailleurs : elle est perdue. L'étape 4 essaie de la rendre à b, mais elle n'existe plus. On finit avec deux fois 9.

La solution demande un troisième casier, dont le seul rôle est de garder la valeur menacée le temps de l'opération.

Retenez le schéma en trois temps, il resservira au chapitre sur les tris : sauvegarder — écraser — restituer.

1tmp ← a2a ← b3b ← tmp

Trois affectations, jamais moins, et l'ordre n'est pas négociable : intervertir deux de ces lignes ramène le bug de la version ratée.

Les types

Le type d'une variable détermine les valeurs qu'elle peut contenir et les opérations qui ont un sens sur elle.

Deux pièges valent le détour. D'abord, + ne veut pas dire la même chose partout : 3 + 4 vaut 7, mais "3" + "4" vaut "34" — la même opération sur des chaînes colle les morceaux bout à bout. Ensuite, la division entière n'est pas la division : 7 / 2 vaut 3.5 en réels, et 7 ÷ 2 vaut 3 en entiers. Cette division entière n'est pas un détail technique ; c'est elle qui fera fonctionner la recherche dichotomique à la leçon 6.

À vous

// Échangez le contenu de a et b.
// Interdit : l'écriture [a, b] = [b, a], qui masque justement le mécanisme
// qu'on cherche à comprendre. Trois affectations, pas une de moins.
let a = 5;
let b = 9;

// à compléter

console.log(a, b); // attendu : 9 5

let a = 5;
let b = 9;

// Sauvegarder — écraser — restituer.
const tmp = a;
a = b;
b = tmp;

console.log(a, b); // 9 5

À retenir

Jusqu'ici, nos algorithmes exécutaient toutes leurs lignes, dans l'ordre, à chaque fois. Un algorithme utile doit pouvoir choisir : afficher un message d'erreur seulement si la saisie est invalide, appliquer une réduction seulement aux adhérents.

Une condition vaut VRAI ou FAUX

C'est le point de départ, et il n'admet aucune nuance. note ≥ 10 n'est pas « la note », n'est pas « 10 » : c'est une expression qui, une fois évaluée, vaut VRAI ou FAUX. Rien d'autre. Pas « à peu près vrai », pas « vrai pour la plupart des étudiants ».

Ces expressions ont même un type, le booléen, et on peut les ranger dans une variable :

1majeur ← (age ≥ 18)2Si majeur Alors3    Écrire("Accès autorisé")4FinSi

Attention à ne pas confondre deux symboles qui se ressemblent : ← affecte, = compare. x ← 5 met 5 dans x ; x = 5 demande si x vaut 5 et répond VRAI ou FAUX. Les langages qui écrivent les deux avec le signe = (comme C ou JavaScript, avec = et ==) causent des bugs par milliers pour cette seule raison.

Les opérateurs de comparaison sont =, ≠, <, >, ≤ et ≥. Ils s'appliquent aux nombres, mais aussi aux chaînes (ordre alphabétique).

Si, Sinon, et l'ordre des cas

1Si condition Alors2    ...instructions si VRAI...3Sinon4    ...instructions si FAUX...5FinSi

Le Sinon est facultatif. Quand il est là, exactement une des deux branches s'exécute — jamais les deux, jamais aucune.

Pour plus de deux cas, on enchaîne avec SinonSi. Et là, l'ordre des tests décide de tout : la cascade s'arrête au premier test vrai et ignore tous les suivants.

Deux enseignements dans cette trace. D'abord, à l'étape 5, on n'a pas eu besoin d'écrire note ≥ 10 ET note < 14 : arriver à ce test signifie déjà que les deux précédents ont échoué. Une cascade bien ordonnée s'écrit avec des conditions plus simples qu'une série de Si indépendants. Ensuite, à l'étape 7, le bloc Sinon n'est même pas examiné : on saute directement au FinSi.

ET, OU, NON

Trois opérateurs suffisent à combiner les conditions.

ET est exigeant : il faut que tout soit vrai. OU est accueillant : il suffit qu'au moins une chose le soit — et c'est un « ou » inclusif, contrairement au français courant où « fromage ou dessert » veut dire l'un ou l'autre mais pas les deux.

Une négation se distribue en inversant l'opérateur. NON(age ≥ 18 ET inscrit) ne signifie pas age < 18 ET NON inscrit, mais age < 18 OU NON inscrit : il suffit qu'une des deux conditions tombe pour que l'ensemble tombe. En cas de doute, le plus sûr reste de laisser le NON devant la parenthèse plutôt que de le distribuer de tête.

Le piège des intervalles

En mathématiques on écrit $0 \leq x \leq 20$. En algorithmique, c'est faux :

1Si 0 ≤ note ≤ 20 Alors     ← à ne pas écrire

Un opérateur de comparaison prend deux opérandes et rend un booléen. La machine évalue donc 0 ≤ note, obtient VRAI ou FAUX, puis essaie de comparer ce booléen à 20 — ce qui n'a aucun sens, et selon le langage produit une erreur ou, pire, un résultat silencieusement faux. Un intervalle s'écrit toujours avec deux comparaisons complètes reliées par ET :

1Si note ≥ 0 ET note ≤ 20 Alors2    ...3FinSi

À vous

// Complétez la cascade. L'ordre des tests décide de tout :
// mettez le test le plus permissif en premier et les autres deviennent
// inatteignables.
function mention(note) {
  if (note >= 10) return "Passable"; // ← ce test est-il au bon endroit ?
  return "Insuffisant";
}

for (const n of [18, 15, 13, 7]) {
  console.log(n, "->", mention(n));
}
// attendu : Très bien / Bien / Passable / Insuffisant

function mention(note) {
  // Du plus exigeant au plus permissif : chaque test suppose que les
  // précédents ont échoué, ce qui évite d'écrire "note >= 10 ET note < 14".
  if (note >= 16) return "Très bien";
  if (note >= 14) return "Bien";
  if (note >= 10) return "Passable";
  return "Insuffisant";
}

for (const n of [18, 15, 13, 7]) {
  console.log(n, "->", mention(n));
}

À retenir