Logique de programmation : agrégation, statistiques simples et accumulation

Objectif : calculer des indicateurs à partir d’une liste

Dans de nombreux problèmes du quotidien, on ne cherche pas à transformer chaque élément d’une liste, mais à produire un ou plusieurs indicateurs globaux : total, moyenne, pourcentage, nombre d’éléments répondant à un critère, etc. On parle alors d’agrégation (on “résume” une collection) et d’accumulation (on met à jour des variables au fil du parcours).

L’idée centrale : pendant le parcours d’une liste, on maintient des accumulateurs (ex. somme, compteur, nb_valides, total_ttc) et on les met à jour à chaque élément. À la fin, on calcule les indicateurs à partir de ces accumulateurs.

Accumulateurs : principes de base

1) Choisir des accumulateurs lisibles

Un accumulateur doit dire clairement ce qu’il contient. Préférez somme_notes_valides à x, nb_presents à c.

• Somme : commence à 0 (ex. somme = 0).
• Compteur : commence à 0 (ex. nb = 0).
• Produit : commence souvent à 1 (mais attention aux listes vides).
• Min/Max : initialiser avec le premier élément valide ou avec une valeur sentinelle (ex. +inf, -inf).

2) Valider les entrées avant d’accumuler

Un indicateur fiable dépend d’entrées fiables. Avant d’ajouter une valeur à une somme ou de l’utiliser dans un calcul, vérifiez :

• Le type attendu (nombre, booléen, chaîne parmi un ensemble).
• Les bornes (ex. note entre 0 et 20).
• Les valeurs manquantes (ex. null, chaîne vide).

3) Éviter la division par zéro

La moyenne et les pourcentages impliquent une division. Si le dénominateur peut être 0 (liste vide, aucun élément valide, aucun inscrit…), il faut décider d’un comportement :

Continuez dans notre application.

Vous pouvez écouter le livre audio écran éteint, recevoir un certificat gratuit pour ce cours et accéder également à 5 000 autres cours en ligne gratuits.

Ou poursuivez votre lecture ci-dessous...

Téléchargez l'application

• Retourner 0 (si cela a du sens métier).
• Retourner null / “non calculable”.
• Lever une erreur contrôlée.

si denominateur == 0 alors retourner null sinon retourner numerateur / denominateur

Indicateurs classiques

Somme

On additionne toutes les valeurs (ou seulement celles qui sont valides).

somme = 0
pour chaque valeur dans liste:
  si valeur est valide:
    somme = somme + valeur

Moyenne

La moyenne est somme / nombre. Le point important : le nombre doit correspondre aux valeurs réellement additionnées (ex. uniquement les valides).

somme = 0
nb = 0
pour chaque valeur dans liste:
  si valeur est valide:
    somme = somme + valeur
    nb = nb + 1
si nb == 0: retourner null
sinon: retourner somme / nb

Comptage conditionnel

On compte combien d’éléments satisfont une condition (ex. “présent”, “note >= 10”, “panier non vide”).

compteur = 0
pour chaque element dans liste:
  si condition(element):
    compteur = compteur + 1

Pourcentage

Un pourcentage est un rapport multiplié par 100. Il faut définir clairement le dénominateur : total des éléments ? total des éléments valides ? total des inscrits ?

si total == 0: retourner null
sinon: retourner (partie / total) * 100

Moyenne pondérée

Chaque valeur a un poids (coefficient). On calcule : (Σ valeur * poids) / (Σ poids). Le piège classique : oublier de sommer les poids, ou accepter des poids invalides (négatifs, nuls selon le contexte).

somme_ponderee = 0
somme_poids = 0
pour chaque (valeur, poids) dans liste:
  si valeur et poids sont valides:
    somme_ponderee = somme_ponderee + valeur * poids
    somme_poids = somme_poids + poids
si somme_poids == 0: retourner null
sinon: retourner somme_ponderee / somme_poids

Accumulation multi-variables

Souvent, on calcule plusieurs indicateurs en une seule passe : total HT, total TTC, nombre d’articles, nombre de paniers, etc. La clé est de regrouper les accumulateurs et de les nommer clairement.

total_ht = 0
total_ttc = 0
nb_articles = 0
pour chaque ligne dans panier:
  si ligne est valide:
    total_ht = total_ht + ligne.prix * ligne.quantite
    nb_articles = nb_articles + ligne.quantite
total_ttc = total_ht * (1 + taux_taxe)

Patrons pratiques (recettes) pour structurer vos calculs

Patron A : “Filtrer puis agréger” (sans créer une nouvelle liste)

Vous validez chaque élément, puis vous mettez à jour les accumulateurs uniquement si l’élément passe les contrôles.

• Avantage : une seule passe, pas de stockage intermédiaire.
• Bon pour : notes invalides, lignes de panier incomplètes, présences mal saisies.

Patron B : “Agrégats parallèles”

Vous maintenez plusieurs compteurs/sommes en même temps (ex. présents/absents, validés/invalides).

• Avantage : résultats détaillés (diagnostic).
• Bon pour : statistiques simples et reporting.

Patron C : “Retour structuré”

Plutôt que de renvoyer une seule valeur, renvoyez un objet/dictionnaire avec plusieurs champs : moyenne, nb_valides, nb_invalides, etc. Cela rend l’algorithme plus réutilisable.

retourner { moyenne: ..., nb_valides: ..., nb_invalides: ... }

Exercices (avec solutions)

Exercice 17 — Moyenne des notes avec gestion des notes invalides

Énoncé : On vous donne une liste de notes (certaines peuvent être invalides : non numériques, manquantes, ou hors de l’intervalle 0–20). Calculez la moyenne des notes valides. Retournez aussi le nombre de notes valides et invalides. Si aucune note valide, la moyenne doit être null.

Étapes :

• Initialiser somme_valides, nb_valides, nb_invalides.
• Parcourir les notes : valider (numérique, 0–20).
• Si valide : ajouter à la somme et incrémenter nb_valides.
• Sinon : incrémenter nb_invalides.
• Calculer la moyenne en évitant la division par zéro.

fonction stats_notes(notes):
  somme_valides = 0
  nb_valides = 0
  nb_invalides = 0

  pour chaque note dans notes:
    si note est un nombre ET note >= 0 ET note <= 20:
      somme_valides = somme_valides + note
      nb_valides = nb_valides + 1
    sinon:
      nb_invalides = nb_invalides + 1

  si nb_valides == 0:
    moyenne = null
  sinon:
    moyenne = somme_valides / nb_valides

  retourner { moyenne: moyenne, nb_valides: nb_valides, nb_invalides: nb_invalides }

Exercice 18 — Panier moyen et total TTC (taux de taxe)

Énoncé : Vous recevez une liste de paniers (un panier = liste de lignes). Chaque ligne contient prix_unitaire et quantite. Calculez : (1) le total TTC de tous les paniers, avec un taux_taxe (ex. 0,20), (2) le panier moyen TTC (moyenne des totaux TTC par panier). Ignorez les lignes invalides (prix < 0, quantité <= 0, champs manquants). Si aucun panier valide (ou aucun panier du tout), le panier moyen doit être null.

Étapes :

• Initialiser total_ttc_global, nb_paniers_valides.
• Pour chaque panier : calculer total_ht_panier en additionnant les lignes valides.
• Convertir en TTC : total_ttc_panier = total_ht_panier * (1 + taux_taxe).
• Décider si le panier est “valide” : par exemple, total_ht_panier > 0.
• Accumuler dans le global et compter les paniers valides.
• Calculer le panier moyen en évitant la division par zéro.

fonction stats_paniers(paniers, taux_taxe):
  total_ttc_global = 0
  nb_paniers_valides = 0

  pour chaque panier dans paniers:
    total_ht_panier = 0

    pour chaque ligne dans panier:
      si ligne.prix_unitaire est un nombre ET ligne.prix_unitaire >= 0
         ET ligne.quantite est un entier ET ligne.quantite > 0:
        total_ht_panier = total_ht_panier + (ligne.prix_unitaire * ligne.quantite)

    si total_ht_panier > 0:
      total_ttc_panier = total_ht_panier * (1 + taux_taxe)
      total_ttc_global = total_ttc_global + total_ttc_panier
      nb_paniers_valides = nb_paniers_valides + 1

  si nb_paniers_valides == 0:
    panier_moyen_ttc = null
  sinon:
    panier_moyen_ttc = total_ttc_global / nb_paniers_valides

  retourner { total_ttc: total_ttc_global, panier_moyen_ttc: panier_moyen_ttc, nb_paniers_valides: nb_paniers_valides }

Exercice 19 — Taux de présence (présent/absent)

Énoncé : On vous donne une liste de statuts de présence pour une séance : "present", "absent", parfois des valeurs invalides. Calculez le taux de présence en pourcentage : nb_presents / (nb_presents + nb_absents) * 100. Les invalides ne doivent pas entrer dans le dénominateur. Si aucun statut valide, retournez null.

Étapes :

• Initialiser nb_presents, nb_absents, nb_invalides.
• Parcourir : incrémenter selon la valeur.
• Calculer le total valide et éviter la division par zéro.

fonction taux_presence(statuts):
  nb_presents = 0
  nb_absents = 0
  nb_invalides = 0

  pour chaque s dans statuts:
    si s == "present":
      nb_presents = nb_presents + 1
    sinon si s == "absent":
      nb_absents = nb_absents + 1
    sinon:
      nb_invalides = nb_invalides + 1

  total_valides = nb_presents + nb_absents
  si total_valides == 0:
    taux = null
  sinon:
    taux = (nb_presents / total_valides) * 100

  retourner { taux_presence: taux, nb_presents: nb_presents, nb_absents: nb_absents, nb_invalides: nb_invalides }

Exercice 20 — Calcul d’une moyenne pondérée (coefficients)

Énoncé : Vous recevez une liste de paires (note, coefficient). Certaines paires peuvent être invalides (note hors 0–20, coefficient non numérique, coefficient <= 0). Calculez la moyenne pondérée. Si la somme des coefficients valides est 0, retournez null. Retournez aussi le détail : somme des coefficients et nombre de paires invalides.

Étapes :

• Initialiser somme_note_x_coeff, somme_coeff, nb_invalides.
• Valider note et coefficient.
• Accumuler note * coeff et coeff.
• Diviser en évitant la division par zéro.

fonction moyenne_ponderee(paires):
  somme_note_x_coeff = 0
  somme_coeff = 0
  nb_invalides = 0

  pour chaque (note, coeff) dans paires:
    si note est un nombre ET note >= 0 ET note <= 20
       ET coeff est un nombre ET coeff > 0:
      somme_note_x_coeff = somme_note_x_coeff + (note * coeff)
      somme_coeff = somme_coeff + coeff
    sinon:
      nb_invalides = nb_invalides + 1

  si somme_coeff == 0:
    moyenne = null
  sinon:
    moyenne = somme_note_x_coeff / somme_coeff

  retourner { moyenne_ponderee: moyenne, somme_coeff: somme_coeff, nb_invalides: nb_invalides }

Erreurs fréquentes et garde-fous

• Compter le mauvais dénominateur : moyenne calculée avec la taille totale de la liste au lieu du nombre d’éléments valides.
• Inclure des invalides dans un pourcentage : fausse le taux (ex. présence).
• Oublier le cas “aucune donnée exploitable” : division par zéro ou résultat trompeur.
• Accumulateurs confus : variables génériques qui rendent le code difficile à relire; préférez des noms explicites et regroupez les calculs par objectif (HT, TTC, compteurs).