Démarche d'analyse modulaire

Plan de cours

Diviser pour régner : du problème de 200 lignes au programme de 4 fonctions

Avant d'écrire la moindre fonction, il faut décomposer le problème. L'analyse modulaire est la compétence centrale du programme officiel 4ème année — et celle qui sépare un bon copain d'un bachelier moyen au correcteur.

Concepts clés

Diviser pour régner : un gros problème devient une hiérarchie de petits.
Arbre d'analyse : représentation des dépendances entre modules.
Rôle unique : chaque module fait une seule chose.
Granularité : 5-20 instructions par module.

Avant de commencer

Q1. Si vous deviez « préparer un repas pour 10 personnes », comment décomposeriez-vous la tâche ?
Q2. Combien de lignes auriez-vous écrites pour résoudre l'exercice du PGCD du chapitre 2 ?
Q3. Que faire si un même code doit servir à 3 endroits différents dans un programme ?

1. Le contenu du cours

1.1 Analogie : organiser un mariage

Vous êtes responsable d'un mariage. Vous ne pouvez pas tenir une liste de 500 micro-tâches en mémoire. Vous décomposez :

Réception → Lieu, Décoration, Repas
Cérémonie → Lieu, Officiant, Cortège
Communication → Invitations, Site web, Confirmations

Puis chaque sous-tâche est elle-même décomposée :

Repas → Menu, Traiteur, Boissons, Service

C'est exactement la démarche en programmation : décomposer hiérarchiquement jusqu'à atteindre des modules simples et autonomes.

1.2 Définition

1.3 L'arbre d'analyse

L'arbre d'analyse représente visuellement la décomposition :

                Programme Principal
                       │
        ┌──────────────┼──────────────┐
        ▼              ▼              ▼
   Module A      Module B        Module C
        │                              │
        ▼                              ▼
   Module A1                      Module C1

Lecture : le programme principal appelle A, B, C. A appelle A1. C appelle C1. Les niveaux inférieurs sont les sous-tâches concrètes.

1.4 Exemple complet — Gestion d'une moyenne de classe

Énoncé. Lire les notes de 25 élèves, afficher la moyenne de la classe, la note maximale, la note minimale, et le nombre d'élèves admis (≥ 10).

Étape 1 — Identification des sous-problèmes

En lisant l'énoncé, on repère quatre besoins :

Saisir les 25 notes,
Calculer la moyenne,
Trouver max et min,
Compter les admis.

Étape 2 — Arbre d'analyse

                    Programme moyenne_classe
                              │
            ┌─────────┬───────┴───────┬──────────────┐
            ▼         ▼               ▼              ▼
        saisir_   calculer_      trouver_max_    compter_
        notes     moyenne          et_min        admis
            │
            ▼
        lire_une_note

Étape 3 — Description de chaque module

Module	Rôle	Entrées	Sortie
`saisir_notes`	Lit 25 notes, les stocke dans un tableau	(aucune)	Tableau de 25 réels
`lire_une_note`	Lit une note, vérifie qu'elle ∈ [0, 20]	(aucune)	Un réel
`calculer_moyenne`	Calcule la somme des notes / taille	Tableau de notes	Un réel
`trouver_max_et_min`	Trouve la plus grande et la plus petite	Tableau de notes	Deux réels
`compter_admis`	Compte les notes ≥ 10	Tableau de notes	Un entier

1.5 Trois critères de qualité d'un module

Critère 1 — Cohésion forte

Le module fait une seule chose. Mauvais nom :

saisir_et_calculer_moyenne    ← fait DEUX choses

Bon découpage :

saisir_notes  +  calculer_moyenne

Critère 2 — Couplage faible

Les modules ne dépendent pas de variables internes des autres. Ils communiquent uniquement par leurs paramètres et leur valeur de retour (vous verrez les paramètres à la leçon 3.3).

Critère 3 — Granularité raisonnable

Trop petit (`< 3` instructions)	Bon (5-20 instructions)	Trop gros (`> 30` instructions)
`module afficher_titre()` qui contient juste `Écrire("Bonjour")` → inutile.	`module trouver_max(T)` qui parcourt T et renvoie le max.	`module gerer_tout()` qui fait saisie + calcul + affichage. À redécomposer.

1.6 Une heuristique pratique

Quand vous lisez un énoncé, soulignez les verbes d'action :

Le programme doit lire N entiers, trier le tableau, chercher une valeur, afficher la position.

Chaque verbe = un candidat-module. Combinés ensuite si trop petits.

1.7 Trace d'analyse — Le palindrome

Énoncé. Lire une chaîne et indiquer si elle est palindrome (lit pareil à l'endroit et à l'envers).

Verbes soulignés : lire, inverser, comparer, afficher.

Arbre d'analyse :

            est_palindrome
                  │
        ┌─────────┼─────────┐
        ▼         ▼         ▼
     lire_chaine inverser  comparer
                 _chaine   _chaines

Module	Rôle
`lire_chaine`	Demander à l'utilisateur de saisir une chaîne
`inverser_chaine`	Retourner la chaîne inversée
`comparer_chaines`	Vérifier l'égalité (en ignorant casse et espaces ?)

Résultat. Un programme principal de 4 lignes :

0) Début est_palindrome
1) ch ← lire_chaine()
2) ch_inv ← inverser_chaine(ch)
3) Si comparer_chaines(ch, ch_inv) Alors Écrire("Palindrome") Sinon Écrire("Non") FinSi
4) Fin est_palindrome

vs. un programme monolithique de 25 lignes. 6× plus compact, infiniment plus lisible.

2. Exercices pratiques

Niveau Débutant — Type bac courant

Exercice 1facile

Souligner les verbes

Pour chacun des énoncés suivants, souligner les verbes d'action et proposer une liste de modules candidats (sans encore écrire de code).

Lire 10 entiers, calculer leur somme et afficher leur moyenne arrondie à 2 décimales.
Convertir une température de Celsius en Fahrenheit, puis afficher les deux valeurs.
Vérifier si un mot saisi est un anagramme d'un mot de référence.

Voir le corrigé

1. Lire 10 entiers, calculer leur somme et afficher leur moyenne

Verbes : lire, calculer (somme), calculer (moyenne), afficher.

Modules candidats :

lire_tableau(N) → retourne tableau de N entiers
somme_tableau(T) → retourne la somme
moyenne (calculée directement dans le main avec somme / N)
L'affichage final reste dans le main

Arbre :

   programme_principal
        │
    ┌───┴───┐
    ▼       ▼
  lire    somme
  _tab    _tab

2. Convertir Celsius en Fahrenheit

Verbes : lire, convertir, afficher.

Modules :

lire_celsius() → réel
celsius_vers_fahrenheit(c) → retourne c * 9/5 + 32
Affichage dans le main

Remarque. Pour un cas si simple (formule unique), on peut être tenté de tout mettre dans le main. C'est OK pour 1 conversion. Si on doit convertir aussi vers Kelvin, Rankine, etc., un module par conversion devient pertinent.

3. Anagramme

Verbes : lire, trier (les lettres), comparer.

Modules :

lire_mot() → chaîne
trier_lettres(mot) → chaîne avec lettres ordonnées
sont_anagrammes(m1, m2) → booléen (utilise trier_lettres deux fois)

Arbre :

       anagramme
          │
   ┌──────┴──────┐
   ▼             ▼
lire_mot   sont_anagrammes
                 │
                 ▼
            trier_lettres

trier_lettres est appelé 2 fois dans sont_anagrammes (une fois pour chaque mot). C'est le gain principal de l'analyse modulaire : éviter la duplication de code.

Niveau Intermédiaire — Type bac difficile

Exercice 2moyen

Arbre d'analyse complet

Énoncé. Construire l'arbre d'analyse d'un programme qui :

demande à l'utilisateur le nombre d'élèves N (entre 1 et 50),
pour chaque élève, lit son nom, sa note de maths et sa note d'informatique,
calcule la moyenne de chaque élève (moyenne pondérée 2/3 maths + 1/3 info),
affiche le classement des élèves par moyenne décroissante,
affiche la moyenne de classe et le taux d'admis.

Donner l'arbre d'analyse et la description de chaque module (rôle, entrées, sorties). N'écrivez pas le code.

Voir le corrigé

Arbre d'analyse

                  classement_eleves
                         │
        ┌────────────┬───┴────┬──────────┬──────────┐
        ▼            ▼        ▼          ▼          ▼
    saisir_N    saisir_   trier_      moyenne_  taux_
                eleves    eleves      classe    admis
                   │
                   ▼
              lire_un_eleve
                   │
                   ▼
              moyenne_ponderee

Modules

Module	Rôle	Entrées	Sortie
`saisir_N`	Demande N ∈ [1, 50] avec validation	—	Entier
`saisir_eleves`	Lit N élèves, les stocke	N	Tableau d'élèves
`lire_un_eleve`	Lit nom, note maths, note info pour un élève, calcule sa moyenne	—	Structure élève (nom + moy)
`moyenne_ponderee`	Calcule (2·M + I) / 3	maths, info	Réel
`trier_eleves`	Trie le tableau par moyenne décroissante	Tableau	Tableau trié
`moyenne_classe`	Calcule la moyenne globale	Tableau	Réel
`taux_admis`	Calcule % d'élèves avec moyenne ≥ 10	Tableau	Réel

Programme principal (squelette)

0) Début classement_eleves
1) N ← saisir_N()
2) eleves ← saisir_eleves(N)
3) trier_eleves(eleves)
4) Pour i de 1 à N Faire Écrire(eleves[i].nom, eleves[i].moy) FinPour
5) Écrire("Moyenne classe : ", moyenne_classe(eleves))
6) Écrire("Taux d'admis : ", taux_admis(eleves), "%")
7) Fin classement_eleves

Programme principal = 7 lignes. Sans analyse modulaire, ce serait 60+ lignes mélangées.

Niveau Avancé — Hors bac (bonus)

Exercice 3difficile

Critique de décomposition

Voici une analyse modulaire fautive pour un programme de jeu du pendu. Identifier au moins 3 défauts et proposer une décomposition corrigée.

            pendu
              │
   ┌──────────┼──────────┐
   ▼          ▼          ▼
saisir_   afficher_   gerer_
mot_et_   mot_avec_   tour_de_
choisir   espaces_    jeu_complet
_lettre   _et_tirets   _avec_
                       affichage
                       _et_test
                       _victoire

Voir le corrigé

Défauts identifiés

Défaut 1 — Cohésion faible. saisir_mot_et_choisir_lettre fait deux choses différentes : (a) saisie initiale du mot par le joueur 1, (b) saisie d'une lettre à chaque tour par le joueur 2. À séparer.

Défaut 2 — Granularité incohérente. afficher_mot_avec_espaces_et_tirets est trop bavardement détaillé : le « avec espaces et tirets » est un détail d'implémentation, pas un nom de module. Renommer en afficher_etat.

Défaut 3 — Modules monolithiques. gerer_tour_de_jeu_complet_avec_affichage_et_test_victoire est un module fourre-tout qui contient toute la logique de jeu. À éclater en plusieurs.

Défaut 4 — Pas de hiérarchie. Tous les modules sont au même niveau. Or tester_lettre est clairement un sous-module de tour_de_jeu.

Décomposition corrigée

                    pendu
                      │
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
   saisir_mot   jouer_partie   afficher_
   _secret                     resultat
                 │
        ┌────────┼────────┐
        ▼        ▼        ▼
   tour_de_  est_      est_
   jeu       gagne     perdu
        │
   ┌────┴────┐
   ▼         ▼
lire_lettre  mettre_a_jour_
             etat

Module	Rôle
`saisir_mot_secret`	Lit le mot que le joueur doit deviner
`jouer_partie`	Boucle principale jusqu'à victoire ou défaite
`tour_de_jeu`	Un tour : lire lettre, mettre à jour, afficher
`lire_lettre`	Saisit et valide une lettre
`mettre_a_jour_etat`	Révèle la lettre dans la chaîne masquée
`est_gagne`	Booléen : toutes les lettres trouvées ?
`est_perdu`	Booléen : trop d'erreurs ?
`afficher_resultat`	Message final (gagné / perdu + mot)

Avantages de cette décomposition :

Chaque module a un nom clair (verbe + objet).
La granularité est homogène (5-15 instructions).
La hiérarchie est explicite : tour_de_jeu contient lire_lettre.
Les modules est_gagne et est_perdu peuvent être réutilisés indépendamment.

⚠️ Erreurs fréquentes au bac

Avant le quiz, mémorisez ces pièges classiques qui font perdre des points :

Erreur 1. Écrire un seul module monolithique de 50 lignes au lieu de décomposer en 4-5 modules de 10 lignes.
Erreur 2. Manque de cohésion : saisir_et_calculer_moyenne fait deux choses. Toujours scinder en saisir + calculer.
Erreur 3. Couplage fort : modules qui partagent des variables globales. Préférer le passage par paramètres explicites.
Erreur 4. Modules trop petits (afficher_bonjour() qui contient juste Écrire("Bonjour")) : inutile, fusionner.

3. Quiz de vérification

Analyse modulaire (5 questions)

En résumé

Avant la leçon 3.2 (Procédures vs Fonctions), vous devez savoir :

✅ Souligner les verbes d'un énoncé pour identifier les modules candidats,
✅ Dessiner un arbre d'analyse propre (hiérarchie + flèches d'appel),
✅ Donner un nom verbe-objet à chaque module,
✅ Détecter une cohésion faible ou une granularité incorrecte dans une décomposition existante.

Sans cette compétence, vos programmes deviendront vite ingérables. C'est l'étape la plus importante du programme officiel 4ème année.