Parcourir un tableau avec une boucle

Introduction

Savoir accéder à Notes[4] ou Scores[0] est un bon début, mais la véritable puissance des tableaux se révèle lorsqu'on les associe aux boucles. C'est ce qui permet d'automatiser le traitement de centaines, voire de milliers de données, sans avoir à écrire des centaines de lignes de code.

Aujourd'hui, nous allons donc nous concentrer sur l'objectif suivant : parcourir un tableau avec une boucle pour lire, modifier ou traiter ses éléments. Vous allez voir comment la boucle Pour, que vous maîtrisez déjà, devient l'outil parfait pour "visiter" chaque case d'un tableau et y effectuer une opération. C'est la compétence clé pour commencer à résoudre des problèmes concrets avec des ensembles de données.

1. Le parcours de tableau : le duo Boucle-Index

Rappelez-vous la structure d'un tableau : une série de cases numérotées de 0 à Taille - 1.
Rappelez-vous également la structure d'une boucle Pour : un compteur qui s'incrémente d'une valeur de départ à une valeur de fin.

La correspondance est parfaite ! On peut utiliser le compteur de la boucle comme index pour le tableau. La structure la plus courante pour parcourir un tableau T de taille N est donc :

Pour i allant de 0 à N-1 Faire
  // Ici, on fait quelque chose avec T[i]
FinPour

À chaque itération de la boucle :

• i vaut 0, on travaille sur T[0].
• i vaut 1, on travaille sur T[1].
• ...
• i vaut N-1, on travaille sur T[N-1].

La boucle s'arrête juste après, garantissant que nous avons traité chaque élément une seule fois, et sans jamais tenter d'accéder à un index qui n'existe pas (comme T[N]).

Voyons maintenant les opérations concrètes que ce parcours nous permet de réaliser.

2. Opération de base : Remplir et Afficher un tableau

Les deux opérations les plus fondamentales sont de remplir un tableau avec des valeurs (lecture) et d'afficher son contenu (écriture). L'exemple d'application du document que nous avons déjà utilisé illustre parfaitement ces deux actions.

Analysons l'algorithme de la ressource :

Algorithme 1 : Remplissage (Lecture)

// Pour un tableau Tab de taille 20
Pour i de 0 à 19
  Ecrire ("Donner une valeur :")
  Lire (Tab[i]) // À l'itération i=0, on remplit Tab[0]. À i=1, on remplit Tab[1], etc.
FinPour

C'est le modèle standard pour peupler un tableau avec des données fournies par l'utilisateur.

Algorithme 2 : Affichage (Écriture)

// Pour le même tableau Tab
Pour i de 0 à 19
  Ecrire ("Valeur ", i, "=", Tab[i]) // À l'itération i=0, on lit et affiche Tab[0], etc.
FinPour

C'est le modèle standard pour inspecter le contenu d'un tableau.

3. Opération de modification

Parcourir un tableau ne sert pas seulement à lire des données. On peut aussi en modifier le contenu. L'idée est la même : on parcourt le tableau, et à chaque case, on effectue une opération d'affectation.

Imaginons que nous ayons un tableau de notes et que nous souhaitions appliquer un bonus de 10% à chaque note.

Algorithme AppliquerBonus

Algorithme AppliquerBonus
Variables
  Tableau Notes[5] : Reel
  i : Entier

Début
  // Étape 1 : On remplit le tableau (comme vu précédemment)
  Ecrire("Veuillez saisir les 5 notes.")
  Pour i allant de 0 à 4 Faire
    Ecrire("Note ", i, " :")
    Lire(Notes[i])
  FinPour

  // Étape 2 : On parcourt le tableau pour modifier chaque élément
  Pour i allant de 0 à 4 Faire
    // On lit la valeur actuelle de Notes[i], on la majore, et on la réaffecte à la même case.
    Notes[i] ← Notes[i] * 1.10
  FinPour

  // Étape 3 : On affiche le résultat pour vérifier
  Ecrire("Notes après application du bonus :")
  Pour i allant de 0 à 4 Faire
    Ecrire(Notes[i])
  FinPour
Fin

Dans la deuxième boucle, l'instruction Notes[i] ← Notes[i] * 1.10 est cruciale. Elle signifie : "La nouvelle valeur de la case i est égale à l'ancienne valeur de la case i multipliée par 1.10".

4. Opération de traitement

Souvent, notre but n'est pas de modifier le tableau, mais d'en extraire une information synthétique. Cela implique de parcourir les éléments pour effectuer un calcul.

Imaginons que nous voulions compter le nombre de notes supérieures ou égales à 10 (la moyenne) dans notre tableau Notes.

Algorithme CompterAdmis

Algorithme CompterAdmis
Variables
  Tableau Notes[5] : Reel
  i : Entier
  nbAdmis : Entier // Un compteur pour notre résultat

Début
  // On suppose que le tableau Notes a déjà été rempli.
  // ...

  // On initialise notre compteur à zéro avant de commencer le calcul.
  nbAdmis ← 0

  // On parcourt le tableau pour examiner chaque note.
  Pour i allant de 0 à 4 Faire
    // Si la note actuelle est supérieure ou égale à 10...
    Si Notes[i] >= 10 Alors
      // ...on incrémente notre compteur.
      nbAdmis ← nbAdmis + 1
    FinSi
  FinPour

  // À la fin de la boucle, le compteur contient le résultat final.
  Ecrire("Nombre d'élèves admis : ", nbAdmis)
Fin

Cet exemple combine tout ce que vous avez appris : les variables, les tableaux, les boucles Pour, les conditions Si...Alors, et la notion de compteur.

5. À vous de jouer !

Maintenant, mettez en pratique ces trois types d'opérations (lecture, modification, affichage) dans un seul algorithme.

Problème :
Écrivez un algorithme complet qui réalise les actions suivantes dans l'ordre :

1. Déclare un tableau nommé Temperatures pour stocker 4 valeurs réelles.
2. Demande à l'utilisateur de saisir ces 4 températures et les stocke dans le tableau.
3. Affiche un message "Températures initiales :", puis affiche chaque température du tableau.
4. Parcourt le tableau et soustrait 1.5 à chaque température.
5. Affiche un message "Températures corrigées :", puis affiche chaque nouvelle température du tableau.

Prenez le temps de l'écrire sur papier. Décomposez le problème en utilisant les modèles que nous venons de voir.

Algorithme GestionTemperatures
Variables
  Tableau Temperatures[4] : Reel
  i : Entier

Début
  // 1. & 2. Déclaration et Remplissage
  Ecrire("Veuillez saisir 4 températures.")
  Pour i allant de 0 à 3 Faire
    Ecrire("Saisir la température n°", i + 1, " :")
    Lire(Temperatures[i])
  FinPour

  // 3. Affichage initial
  Ecrire("---")
  Ecrire("Températures initiales :")
  Pour i allant de 0 à 3 Faire
    Ecrire(Temperatures[i])
  FinPour

  // 4. Modification
  Pour i allant de 0 à 3 Faire
    Temperatures[i] ← Temperatures[i] - 1.5
  FinPour

  // 5. Affichage final
  Ecrire("---")
  Ecrire("Températures corrigées :")
  Pour i allant de 0 à 3 Faire
    Ecrire(Temperatures[i])
  FinPour
Fin

Conclusion

Félicitations ! Vous savez maintenant comment manipuler des collections de données. C'est une étape majeure. Le parcours d'un tableau à l'aide d'une boucle est l'une des opérations les plus fondamentales et les plus fréquentes en algorithmique et en programmation.

Points clés à retenir :

• L'association d'une boucle Pour et d'un tableau est la méthode standard pour traiter tous les éléments d'une collection.
• La variable de la boucle (le compteur) est utilisée comme index pour accéder à l'élément courant : Tableau[i].
• Les bornes de la boucle doivent correspondre aux indices valides du tableau, typiquement de 0 à Taille - 1.
• Ce parcours permet de réaliser trois grandes familles d'opérations :
  1. Lecture : pour remplir le tableau.
  2. Modification : pour mettre à jour les valeurs dans le tableau.
  3. Traitement : pour lire les valeurs et en calculer un résultat (ex: un compteur).

Et après ?

Dans la prochaine leçon, nous continuerons à explorer les opérations de traitement. Maintenant que vous savez parcourir un tableau, nous allons nous en servir pour effectuer des calculs statistiques de base mais essentiels : calculer la somme et la moyenne des éléments d'un tableau.