Du problème à l'algorithme

Objectifs

À la fin de cette leçon, vous saurez :

• décomposer tout problème en trio entrée / traitement / sortie ;
• écrire un algorithme en pseudo-code avant de coder, et expliquer pourquoi ;
• découper un problème complexe en sous-problèmes indépendants ;
• identifier les cas particuliers avant qu'ils ne cassent votre programme.

Le schéma de tout traitement informatique

Quel que soit le programme — un script de cinq lignes ou une plateforme entière — la structure logique est toujours la même :

ENTRÉE              TRAITEMENT                    SORTIE
(données)    →     (étapes finies et ordonnées)  →   (résultat)

Trois exemples pour installer le réflexe :

Problème	Entrée	Sortie
Calculer une moyenne	liste de notes	nombre
Trouver le plus grand	liste de nombres	nombre
Tester un mot de passe	chaîne	vrai / faux

Remarquez que la colonne « traitement » est vide dans ce tableau : c'est volontaire. Poser entrée et sortie d'abord force à définir le contrat avant la mécanique — et c'est déjà faire de l'algorithmique.

Qu'est-ce qu'un algorithme ?

Un algorithme est une suite d'étapes finies (ça se termine), ordonnées (l'ordre compte) et non ambiguës (chaque étape s'entend d'une seule façon) qui transforme l'entrée en sortie. Une recette de cuisine, une notice IKEA, un itinéraire : des algorithmes au sens plein. La différence avec un programme : le programme est l'algorithme écrit dans un langage précis.

Le pseudo-code permet d'écrire l'algorithme sans subir aucune syntaxe :

ALGORITHME maximum
ENTRÉES : liste de nombres
SORTIE : le plus grand nombre, ou « rien » si la liste est vide

1. Si la liste est vide → répondre « rien »
2. Prendre le premier élément comme candidat
3. Pour chaque élément suivant :
     si l'élément est plus grand que le candidat,
     il devient le nouveau candidat
4. Répondre le candidat

Pourquoi passer par là plutôt que coder directement ? Trois raisons concrètes, vérifiables dès ce chapitre :

1. On raisonne sur la logique, pas sur les points-virgules. Les erreurs trouvées ici coûtent zéro ligne de code ;
2. On teste à la main : déroulez le pseudo-code sur papier avec [4, 9, 2] — vous venez de déboguer sans machine ;
3. La traduction devient triviale : chaque ligne de pseudo-code devient une ou deux lignes de JavaScript, sans surprise.

Exemple complet : du besoin flou au code

Suivons le chemin intégral sur un problème réaliste : « afficher le panier moyen d'un client ».

Étape 1 — cadrer le trio. Entrée : liste des montants du panier. Sortie : un montant moyen, affiché en euros. Déjà, une question surgit : que faire si le panier est vide ? On décide maintenant : afficher 0 € (décision métier, pas technique).

Étape 2 — décomposer si nécessaire.

panier moyen
├── A. calculer la somme des montants      (sous-problème classique)
├── B. diviser par le nombre d'articles    (trivial)
└── C. gérer le cas vide                   (gardé pour l'étape pseudo-code)

Chaque sous-problème reçoit son propre mini-trio — et deviendra sa propre fonction.

Étape 3 — pseudo-code.

ALGORITHME panierMoyen
ENTRÉES : liste de montants
SORTIE : texte du type « Panier moyen : X € »

1. Si la liste est vide → répondre « Panier moyen : 0 € »
2. total ← somme des montants
3. moyenne ← total ÷ nombre d'éléments
4. Répondre « Panier moyen : {moyenne arrondie} € »

Étape 4 — test à la main (trace). Avec [10, 20, 30] : total = 60 ; moyenne = 20 ; réponse attendue : « Panier moyen : 20 € ». Avec [] : réponse « Panier moyen : 0 € ». Deux exécutions mentales, deux contrats vérifiés.

Étape 5 — traduction. Chaque sous-problème devient une fonction connue (somme existe déjà depuis la prochaine leçon !) :

function panierMoyen(montants) {
  if (montants.length === 0) {
    return "Panier moyen : 0 €";
  }
  let total = 0;
  for (const m of montants) {
    total += m;
  }
  const moyenne = total / montants.length;
  return `Panier moyen : ${moyenne.toFixed(2)} €`;
}

console.log(panierMoyen([10, 20, 30]));   // Panier moyen : 20.00 €
console.log(panierMoyen([]));             // Panier moyen : 0 €

Cinq étapes, zéro improvisation devant l'éditeur. C'est ce processus — pas un talent mystérieux — qu'on appelle savoir programmer.

Décomposer pour vaincre

La décomposition est votre outil principal face à un problème intimidant :

Problème : afficher la moyenne des notes supérieures à 10
    ↓ décomposition
1. filtrer les notes ≥ 10        (sous-problème A)
2. calculer la moyenne du filtre (sous-problème B)
3. afficher                      (sous-problème C, trivial)

Deux critères disent quand on a fini de découper :

• chaque sous-problème tient dans une phrase ;
• chacun a son propre trio entrée/traitement/sortie clair.

Si un sous-problème reste flou (« traiter les données »), il attend encore d'être découpé.

Les cas particuliers, ennemis silencieux

Un algorithme naïf marche sur l'exemple type et casse aux bords. Interrogez-vous systématiquement :

Question	Exemple de piège
Liste vide ?	moyenne = division par zéro ; maximum inexistant
Élément absent ?	recherche qui tourne dans le vide, retour non prévu
Valeurs égales ?	deux maxima ex æquo : lequel gagnera ?
Entrée invalide ?	"abc" là où un nombre était attendu
Un seul élément ?	boucles écrites pour deux éléments minimum

L'algorithme maximum ci-dessus traite explicitement la liste vide à l'étape 1 : ce réflexe — traiter les bords dans l'algorithme, pas après coup — distingue un code robuste d'un code chanceux.

Exercice

Écrivez le pseudo-code (pas le JavaScript) des algorithmes suivants, avec gestion explicite des cas particuliers. Pour chacun : entrée, sortie, étapes numérotées, comportement des cas limites.

1. Somme des nombres pairs d'une liste.
2. Recherche : dire si une valeur donnée existe dans une liste.
3. Compter combien de fois une lettre apparaît dans un texte.
4. Bonus de rigueur : pour l'algorithme 2, déroulez-le à la main sur ["a", "b"] avec la valeur "b" — combien d'étapes avant la réponse ?

Résumé

• Entrée → traitement → sortie : le cadre universel ; définir entrée/sortie AVANT le traitement.
• Pseudo-code d'abord : la logique se règle sans syntaxe, puis la traduction est triviale.
• Décomposer jusqu'à des sous-problèmes tenables en une phrase.
• Les cas particuliers font partie de l'algorithme ; ils se décident, jamais subissent.

ALGORITHME sommePairs
ENTRÉES : liste de nombres
SORTIE : nombre (0 si aucune valeur paire)

1. total ← 0
2. Pour chaque n de la liste :
     si le reste de n ÷ 2 vaut 0,
     alors total ← total + n
3. Répondre total

ALGORITHME contient
ENTRÉES : liste, valeur cherchée
SORTIE : vrai ou faux

1. Pour chaque élément de la liste :
     si l'élément est égal à la valeur → répondre vrai
2. Après la boucle complète → répondre faux

ALGORITHME compterLettre
ENTRÉES : texte, lettre
SORTIE : nombre d'apparitions

1. compteur ← 0
2. Pour chaque caractère du texte :
     si le caractère est identique à la lettre → compteur ← compteur + 1
3. Répondre compteur