Tableaux et parcours

Vingt notes à traiter ne justifient pas vingt variables. Le tableau est la structure qui regroupe plusieurs valeurs de même type sous un seul nom, chacune repérée par un numéro.

1Variables2    T : tableau de 5 entiers3Début4    T[0] ← 125    T[1] ← 56    ...

Deux propriétés à retenir. Toutes les cases ont le même type : un tableau d'entiers ne contient que des entiers. Et l'accès à une case est immédiat : atteindre T[3] ne coûte pas plus cher que T[0], la machine n'a pas à parcourir les cases précédentes. Ce détail paraît anodin ; c'est lui qui rendra possible la recherche dichotomique de la leçon 6.

Les cases sont numérotées de 0 à n − 1

C'est la convention de la quasi-totalité des langages, et la source d'erreur numéro un des débutants. Un tableau de 5 cases a pour indices 0, 1, 2, 3, 4. Il n'y a pas de case 5.

La première case est T[0], la dernière est T[n − 1] où n est la taille. Retenez ces deux formes plutôt que des nombres : elles restent justes quelle que soit la taille.

Accéder à T[5] sur ce tableau est un débordement d'indice. Selon le langage, le programme s'arrête net, ou — bien pire — lit un morceau de mémoire qui ne lui appartient pas et continue avec une valeur absurde.

Le parcours

Parcourir un tableau, c'est visiter ses cases une par une, dans l'ordre. Le schéma est toujours le même, et il vaut la peine de l'écrire une fois pour toutes :

1Pour i de 0 à n − 1 Faire2    ...traiter T[i]...3FinPour

Notez n − 1, pas n. Écrire Pour i de 0 à n produit un tour de trop, et ce tour déborde. C'est l'erreur « à un près », la plus fréquente et la plus discrète du semestre.

Une seule boucle a produit trois résultats. C'est un réflexe à prendre : quand plusieurs grandeurs se calculent sur les mêmes données, on ne fait pas trois parcours, on en fait un seul avec trois accumulateurs.

Somme, moyenne, minimum, maximum

Ces quatre calculs sont les exercices d'application obligés du parcours, et trois d'entre eux cachent un piège d'initialisation.

La somme ne pose pas de problème : accumulateur à 0, puis somme ← somme + T[i].

La moyenne se calcule après la boucle, une seule fois : moyenne ← somme / n. Diviser à l'intérieur donnerait un résultat faux à chaque tour sauf le dernier.

Le minimum et le maximum sont le vrai piège. La tentation est d'écrire :

1max ← 0                          ← FAUX2Pour i de 0 à n − 1 Faire3    Si T[i] > max Alors max ← T[i] FinSi4FinPour

Sur [12, 5, 20, 8, 3], ça marche. Sur un tableau de températures hivernales [−3, −8, −5], le résultat est 0 — une température qui n'apparaît nulle part dans les données. Le maximum d'un tableau est forcément une valeur du tableau ; il faut donc partir de l'une d'elles :

1max ← T[0]2Pour i de 1 à n − 1 Faire3    Si T[i] > max Alors max ← T[i] FinSi4FinPour

Même raisonnement pour le minimum. Cette règle s'énonce simplement : on initialise avec la première valeur, jamais avec une constante inventée.

À vous

// Un seul parcours, quatre résultats.
// Consigne : écrivez la boucle sur les INDICES. Pas de reduce, pas de
// Math.min(...t) — c'est le parcours qu'on apprend ici, pas la bibliothèque.
const T = [12, -5, 20, 8, 3];

function analyser(t) {
  let somme = 0;
  let min = 0;   // ← initialisation piégée : corrigez-la
  let max = 0;   // ← celle-ci aussi

  for (let i = 0; i < t.length; i++) {
    // à compléter
  }

  return { somme, min, max, moyenne: somme / t.length };
}

console.log(analyser(T));
// attendu : { somme: 38, min: -5, max: 20, moyenne: 7.6 }

const T = [12, -5, 20, 8, 3];

function analyser(t) {
  let somme = 0;
  // On part de la PREMIÈRE VALEUR, jamais de 0 : avec un tableau de
  // températures négatives, un max initialisé à 0 ne serait jamais remplacé.
  let min = t[0];
  let max = t[0];

  for (let i = 0; i < t.length; i++) {
    somme = somme + t[i];
    if (t[i] < min) min = t[i];
    if (t[i] > max) max = t[i];
  }

  // La moyenne se calcule APRÈS la boucle, une seule fois.
  return { somme, min, max, moyenne: somme / t.length };
}

console.log(analyser(T));

À retenir