Boucles et Agrégations : Compteurs et Accumulateurs

Bonjour !

Dans la leçon précédente, nous avons appris à choisir entre une boucle Pour et une boucle Tant que en fonction de si le nombre de répétitions est connu ou non. Maintenant que vous maîtrisez la construction des boucles, nous allons nous intéresser à ce que l'on fait le plus souvent à l'intérieur : des calculs répétitifs.

Introduction

Cette leçon se concentre sur deux schémas algorithmiques fondamentaux que vous utiliserez constamment : les compteurs et les accumulateurs. L'objectif est de vous apprendre à manipuler ces variables à l'intérieur d'une boucle pour calculer des sommes, des totaux, des moyennes ou simplement pour compter des éléments.

Maîtriser ces techniques est essentiel pour résoudre une multitude de problèmes pratiques. C'est un pas de plus vers l'écriture d'algorithmes non seulement fonctionnels, mais aussi logiques et efficaces, ce qui est au cœur de votre objectif d'écrire du "code clean".

1. L'Accumulateur : Calculer des Sommes et des Totaux

Imaginez que vous faites vos courses. Vous ne payez pas chaque article séparément ; le caissier scanne chaque article et l'ajoute à un total courant. Ce total est un accumulateur.

En algorithmique, un accumulateur est une variable dont le but est d'agréger (additionner, multiplier, etc.) des valeurs au fil des itérations d'une boucle pour obtenir un résultat final.

Pour utiliser un accumulateur correctement, on suit une méthode en trois temps, que l'on peut appeler la règle des 3 "I" :

Initialisation : Avant la boucle, on donne à l'accumulateur une valeur de départ. Pour une somme, c'est 0. Pour un produit, ce serait 1.
Incrémentation (Mise à jour) : À l'intérieur de la boucle, à chaque tour, on met à jour la valeur de l'accumulateur. Par exemple : total ← total + nouvelle_valeur.
Interprétation (Utilisation) : Après la fin de la boucle, la variable contient le résultat final et peut être utilisée (affichée, utilisée dans un autre calcul, etc.).

La ressource suivante introduit cette idée avec une analogie simple et des exemples concrets.

Accumulateurs et compteurs

Pour bien saisir le concept d'accumulateur, lisez la première partie de ce document. Il utilise une petite histoire pour illustrer l'idée avant de montrer un exemple de calcul de moyenne.

Lisez la section "I. Les accumulateurs". Observez bien les trois étapes : l'initialisation de la variable avant la boucle, sa mise à jour à l'intérieur, et son utilisation après. L'exemple du calcul de moyenne est une application directe.

Voici un algorithme de base pour calculer la somme des entiers de 1 à un nombre N donné, en appliquant la règle des 3 "I" :

Algorithme SommeEntiers

Variables
  N : Entier      // La limite supérieure
  i : Entier      // Le "curseur" de notre boucle
  somme : Entier  // Notre accumulateur

Début
  // On demande jusqu'où on doit sommer
  Afficher "Entrez un nombre entier positif :"
  Lire N

  // 1. Initialisation de l'accumulateur
  somme ← 0

  // 2. Incrémentation dans la boucle
  Pour i allant de 1 à N Faire
    somme ← somme + i
  FinPour

  // 3. Interprétation du résultat
  Afficher "La somme des entiers de 1 à " + N + " est : " + somme
Fin

L'organigramme ci-dessous illustre visuellement ce processus pour calculer la somme des nombres de 1 à 50. La variable Sum est l'accumulateur et N sert à la fois de compteur pour la boucle et de valeur à ajouter.

Flowchart for Summing Numbers from 1 to 50 — Cet organigramme montre le fonctionnement d'un accumulateur (`Sum`) et d'un compteur (`N`). À chaque tour de boucle, `N` est incrémenté, puis sa nouvelle valeur est ajoutée à `Sum`. Le processus s'arrête lorsque `N` atteint 50.

2. Le Compteur : Dénombrer des Occurrences

Un compteur est une forme simplifiée d'accumulateur. Son unique rôle est de compter le nombre de fois qu'un événement se produit ou qu'une condition est vraie. La valeur ajoutée à chaque fois est fixe, presque toujours 1.

Le compteur suit la même règle des 3 "I" :

Initialisation : compteur ← 0 avant la boucle.
Incrémentation : compteur ← compteur + 1 à l'intérieur de la boucle, souvent dans une structure conditionnelle (Si...Alors).
Interprétation : Utilisation du résultat final après la boucle.

Le besoin d'un compteur apparaît souvent lorsqu'on doit filtrer des données. La ressource suivante l'introduit de manière très naturelle.

Accumulateurs et compteurs

Maintenant, voyons le compteur. Ce document montre comment, en voulant affiner un calcul de moyenne (ne compter que les notes paires), on est obligé d'introduire une nouvelle variable pour compter le nombre d'éléments valides.

Lisez la section "II. Les compteurs". Remarquez comment le calcul de la moyenne devient faux si l'on ne compte pas le nombre réel de notes prises en compte. Cela démontre parfaitement l'utilité d'un compteur.

Voici un exemple où l'on compte le nombre de notes supérieures ou égales à 10 dans une série de 5 notes :

Algorithme CompterAdmis

Variables
  i : Entier
  note : Réel
  nbAdmis : Entier  // Notre compteur

Début
  // 1. Initialisation du compteur
  nbAdmis ← 0

  Afficher "Veuillez entrer 5 notes."
  Pour i allant de 1 à 5 Faire
    Afficher "Entrez la note N°" + i + " :"
    Lire note
    
    // 2. Incrémentation conditionnelle
    Si note ≥ 10 Alors
      nbAdmis ← nbAdmis + 1
    FinSi
  FinPour

  // 3. Interprétation du résultat
  Afficher "Il y a " + nbAdmis + " notes supérieures ou égales à 10."
Fin

3. Application Pratique : Calculer une Moyenne

L'un des usages les plus courants de l'association d'un accumulateur et d'un compteur est le calcul d'une moyenne.

Moyenne = Somme totale des valeurs / Nombre total de valeurs

Pour calculer une moyenne, il nous faut donc :

Un accumulateur (somme) pour calculer la somme totale.
Un compteur (nbValeurs) pour compter le nombre de valeurs.

L'algorithme qui en découle est une combinaison directe des deux schémas vus précédemment.

Algorithme CalculMoyenne

Variables
  N : Entier         // Nombre de notes à saisir
  i : Entier
  note : Réel
  somme : Réel       // Accumulateur
  nbNotes : Entier   // Compteur

Début
  Afficher "Combien de notes voulez-vous saisir ?"
  Lire N
  
  // Initialisations
  somme ← 0
  nbNotes ← 0

  // Boucle de saisie et de calcul
  Pour i allant de 1 à N Faire
    Afficher "Entrez la note N°" + i + " :"
    Lire note
    
    // Mise à jour de l'accumulateur
    somme ← somme + note
    // Mise à jour du compteur
    nbNotes ← nbNotes + 1
  FinPour

  // Utilisation des résultats, avec une protection
  Si nbNotes > 0 Alors
    moyenne ← somme / nbNotes
    Afficher "La moyenne des " + nbNotes + " notes est : " + moyenne
  Sinon
    Afficher "Aucune note n'a été saisie, impossible de calculer la moyenne."
  FinSi
Fin

Point de vigilance : Notez la condition Si nbNotes > 0. Avant de faire une division, il est crucial de s'assurer que le diviseur n'est pas zéro pour éviter une erreur. C'est un réflexe important à développer pour écrire des algorithmes robustes.

4. Mise en Pratique

Comme vous préférez la pratique, voici quelques exercices pour consolider ces concepts. Essayez de les résoudre par vous-même avant de regarder la solution.

Exercice 1 : Calcul de la factorielle
La factorielle d'un nombre entier n (notée n!) est le produit de tous les entiers de 1 à n. Par exemple, $5! = 1 \times 2 \times 3 \times 4 \times 5 = 120$ .
Écrivez un algorithme qui demande un entier n à l'utilisateur et calcule sa factorielle.
Indice : C'est un accumulateur, mais avec quelle opération et quelle valeur initiale ?

Cliquez ici pour voir une solution

Algorithme CalculFactorielle

Variables
  n : Entier
  i : Entier
  factorielle : Entier // Notre accumulateur (produit)

Début
  Afficher "Entrez un entier positif :"
  Lire n

  // 1. Initialisation pour un produit
  factorielle ← 1

  // Cas particulier : 0! = 1, et on ne boucle pas pour n=0
  Si n > 0 Alors
    // 2. Mise à jour dans la boucle
    Pour i allant de 1 à n Faire
      factorielle ← factorielle * i
    FinPour
  FinSi

  // 3. Utilisation du résultat
  Afficher n + "! = " + factorielle
Fin

Exercice 2 : Moyenne des nombres pairs
Écrivez un algorithme qui demande à l'utilisateur de saisir 10 nombres entiers, puis qui calcule et affiche la moyenne uniquement des nombres pairs saisis.

Cliquez ici pour voir une solution

Algorithme MoyenneNombresPairs

Variables
  i : Entier
  nombre : Entier
  sommePairs : Entier      // Accumulateur
  nbPairs : Entier         // Compteur

Début
  // Initialisations
  sommePairs ← 0
  nbPairs ← 0
  
  Afficher "Veuillez saisir 10 nombres entiers."
  Pour i allant de 1 à 10 Faire
    Afficher "Entrez le nombre N°" + i + " :"
    Lire nombre
    
    // On vérifie si le nombre est pair (le reste de la division par 2 est 0)
    Si nombre % 2 == 0 Alors
      sommePairs ← sommePairs + nombre
      nbPairs ← nbPairs + 1
    FinSi
  FinPour

  // Calcul et affichage final
  Si nbPairs > 0 Alors
    moyenne ← sommePairs / nbPairs
    Afficher "Il y avait " + nbPairs + " nombres pairs."
    Afficher "Leur moyenne est : " + moyenne
  Sinon
    Afficher "Aucun nombre pair n'a été saisi."
  FinSi
Fin

Conclusion

Aujourd'hui, vous avez ajouté deux outils puissants et très fréquents à votre boîte à outils d'algorithmicien.

Points clés à retenir :

Un accumulateur sert à calculer une somme ou un total en agrégeant des valeurs à chaque tour de boucle.
Un compteur sert à dénombrer des éléments, généralement en s'incrémentant de 1 lorsque une condition est remplie.
La règle des 3 "I" (Initialisation, Incrémentation, Interprétation) est un guide fiable pour les utiliser correctement.
La combinaison d'un accumulateur et d'un compteur est la méthode standard pour calculer une moyenne.

Et après ?

Nous savons maintenant créer des boucles et effectuer des calculs à l'intérieur. Mais que se passe-t-il si nous avons besoin d'une boucle à l'intérieur d'une autre boucle ? C'est ce que nous verrons dans la prochaine leçon en abordant les boucles imbriquées. Elles nous ouvriront la porte au traitement de données plus complexes, comme des grilles, des tables ou des images.

Recommended resources