Parcourir, sommer, compter

Objectifs

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

• accumuler un résultat au fil d'un parcours de tableau ;
• écrire les algorithmes somme, minimum, maximum sans bibliothèque ;
• compter les occurrences d'une valeur ou d'un critère ;
• traiter proprement le cas du tableau vide.

🔗 Pour vous rafraîchir la mémoire : du problème à l'algorithme · conditions et boucles

L'accumulateur : le motif central

Presque tous ces algorithmes suivent le même squelette :

let total = 0;                    // 1. accumulateur initialisé
for (const n of nombres) {        // 2. parcours complet
  total += n;                     // 3. accumulation
}
// 4. total contient le résultat

Ce motif « initialise → parcourt → accumule » couvre sommes, comptages, minima, maxima, recherches. Apprenez-le une fois, réutilisez-le partout.

La somme

function somme(nombres) {
  let total = 0;
  for (const n of nombres) {
    total += n;
  }
  return total;
}

console.log(somme([4, 8, 15]));   // 27
console.log(somme([]));           // 0 : la boucle ne tourne pas,
                                  // l'initialisation est renvoyée telle quelle

Le tableau vide fonctionne naturellement : retour de la valeur neutre (0 pour une somme).

Minimum et maximum

Version manuelle (celle qui compte) :

function maximum(nombres) {
  if (nombres.length === 0) {
    return null;                 // pas de maximum sans élément !
  }
  let candidat = nombres[0];     // le premier élément comme point de départ
  for (const n of nombres) {
    if (n > candidat) {
      candidat = n;
    }
  }
  return candidat;
}

Deux points de vigilance :

• Ne jamais partir de 0 : avec let candidat = 0, maximum([-5, -2]) répondrait faussement 0. On part du premier élément.
• Le tableau vide n'a aucun maximum : on choisit explicitement de répondre null plutôt que de mentir.

Le minimum est symétrique : comparaison inversée (<). À vous de l'écrire dans les exercices.

La version bibliothèque existe aussi — à connaître pour lire le code des autres :

Math.max(4, 8, 15);              // 15, mais pas de liste directe
Math.max(...nombres);            // étalement : attention aux très grandes listes

Compter les occurrences

function compter(valeurs, cible) {
  let compteur = 0;
  for (const v of valeurs) {
    if (v === cible) {
      compteur += 1;
    }
  }
  return compteur;
}

console.log(compter([1, 2, 1, 3, 1], 1));   // 3
console.log(compter([1, 2, 1], 9));         // 0

Même accumulateur ; seule la condition d'accumulation change.

Compter selon un critère

function compterPairs(nombres) {
  let compteur = 0;
  for (const n of nombres) {
    if (n % 2 === 0) {
      compteur += 1;
    }
  }
  return compteur;
}

Le critère peut être n'importe quelle expression booléenne : pair/impair, longueur minimale, préfixe de chaîne…

Variantes du motif : la factorielle

L'accumulateur ne somme pas forcément. La factorielle de n (écrite n!) multiplie tous les entiers de 1 à n : 5! = 1 × 2 × 3 × 4 × 5 = 120. Même motif, accumulateur initialisé à 1 et opération × :

function factorielle(n) {
  let produit = 1;                 // neutre pour × (comme 0 l'est pour +)
  for (let i = 2; i <= n; i++) {
    produit = produit * i;
  }
  return produit;
}

Deux points de vigilance hérités du motif :

• l'élément neutre change avec l'opération : 0 pour une somme, 1 pour un produit ;
• le cas particulier n = 0 tombe naturellement juste : la boucle ne tourne pas, la fonction rend 1 — et c'est la définition mathématique (0! = 1).

Ajoutez cette fonction à votre série : elle réutilise le motif de la somme, du maximum et du comptage sans rien de nouveau — c'est exactement le signe qu'un motif est maîtrisé.

Exercice

Écrivez chaque fonction et testez-la sur au moins trois jeux de données dont un tableau vide :

1. somme(nombres) — déjà vue, refaites-la sans regarder.
2. minimum(nombres) — version manuelle, null si vide.
3. compterImpairs(nombres) — nombre d'éléments impairs.
4. sommePositifs(nombres) — somme des seuls éléments strictement positifs.
5. moyenne(nombres) — moyenne arithmétique ; décidez et documentez le comportement pour une liste vide.
6. plusLongue(chaines) — la plus longue chaîne d'un tableau ; en cas d'égalité, la première rencontrée.

Résumé

• Motif universel : initialiser un accumulateur, parcourir, accumuler sous condition.
• Minimum/maximum : partir du premier élément, jamais de 0 ; gérer le vide par null.
• Un compteur est un accumulateur qui avance de 1 quand un critère est vrai.

function minimum(nombres) {
  if (nombres.length === 0) {
    return null;
  }
  let candidat = nombres[0];
  for (const n of nombres) {
    if (n < candidat) {
      candidat = n;
    }
  }
  return candidat;
}

function compterImpairs(nombres) {
  let compteur = 0;
  for (const n of nombres) {
    if (n % 2 !== 0) {
      compteur += 1;
    }
  }
  return compteur;
}

function sommePositifs(nombres) {
  let total = 0;
  for (const n of nombres) {
    if (n > 0) {
      total += n;
    }
  }
  return total;
}

function moyenne(nombres) {
  if (nombres.length === 0) {
    return null;   // décision documentée : pas de moyenne sans note
  }
  return somme(nombres) / nombres.length;
}

function plusLongue(chaines) {
  if (chaines.length === 0) {
    return null;
  }
  let candidate = chaines[0];
  for (const chaine of chaines) {
    if (chaine.length > candidate.length) {
      candidate = chaine;         // strictement > : garde la première en cas d'égalité
    }
  }
  return candidate;
}