Séance 4 — Les tableaux

Ranger, parcourir, chercher, transformer

Dr. El Hadji Bassirou TOURÉ

Département de Mathématiques et Informatique, Faculté des Sciences et Techniques, Université Cheikh Anta Diop de Dakar

Objectifs de la séance

Ce que la séance construit

Le tableau, qui range \(n\) valeurs de même type sous un seul nom, chacune repérée par un indice de 1 à \(n\) : sa déclaration, la lecture et l’écriture d’une case, le parcours de ses indices par une boucle Pour, les traitements qui reviennent partout (somme, moyenne, comptage, recherche, maximum, inversion, décalage) et les deux erreurs propres aux tableaux : l’indice hors bornes et la case non remplie. Chaque algorithme est suivi pas à pas : la ligne exécutée, le tableau en cases, les variables, ce qu’écrit Écrire.

  • Déclarer un tableau, désigner une case par un indice calculé, lire et écrire une case.
  • Dérouler à la main un parcours par Pour : remplissage, somme, moyenne, comptage.
  • Chercher une valeur avec arrêt dès qu’elle est trouvée, et compter les comparaisons.
  • Trouver le maximum d’un tableau et sa position.
  • Inverser et décaler un tableau en place, dans le bon sens de parcours.
  • Repérer, par une trace, un indice hors bornes et une case lue avant d’être remplie.

Les conventions du pseudo-code

écriture sens
\(x\leftarrow e\) ; Lire n ; Écrire "tour", i affectation ; lecture au clavier ; écriture, puis à la ligne
\(=\ \neq\ <\ \leq\ >\ \geq\) ; ET OU NON ; \(+\ -\ \times\) ; div mod comparaisons, connecteurs, opérations
TantQue ; Pour \(i\) de \(a\) à \(b\) [pas \(p\)] ; Répéter … Jusqu’à boucles (Séance 3) ; Pour : tant que \(i\leq b\) (\(i\geq b\) si \(p<0\))
\(C_1\) ET \(C_2\) ; \(C_1\) OU \(C_2\) les deux membres sont toujours évalués (Séance 2)
\(a\,/\,b\) un réel, écrit avec au moins une décimale : \(200/5\) donne 40,0
T : tableau[1..n] déntiers \(n\) cases d’indices 1 à \(n\), non remplies ; taille fixe
T[i] la case d’indice \(i\), \(1\leq i\leq n\) ; indice calculé : T[i + 1]
T[i] \(\leftarrow e\) ; Lire T[i] remplit la case \(i\) ; les autres ne changent pas
T \(\leftarrow\) [12, 8, 15, 9, 14] cases 1 à \(n\) dans l’ordre ; autant de valeurs que de cases
erreurs : arrêt de l’exécution indice hors de 1 à \(n\) ; case non remplie lue ; division par zéro (Séance 2)

Un tableau de \(n\) cases n’a ni T[0] ni T[n + 1] ; \(58/5\) donne 11,6.

Le tableau : un nom, \(n\) cases, des indices

Trente notes dans trente variables : trente noms. Le tableau les range sous un seul nom.

{Tableau T : tableau[1..n] déntiers}

\(n\) cases de même type sous un même nom, repérées par un indice de 1 à \(n\) ; T[i] est la case d’indice \(i\), et \(i\) peut être une expression.

Lecture. L’indice choisit la case : T[3] vaut 15 ; avec \(i=2\), T[i + 1] est encore T[3].

La lecture et l’écriture d’une case, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

7 22

Lecture. Ligne 1 : déclaration de T, tableau de 4 entiers d’indices 1 à 4 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 2 : T[1] ← 4 ; la case T[1] reçoit 4.

Lecture. Ligne 3 : T[2] ← 7 ; la case T[2] reçoit 7.

Lecture. Ligne 4 : T[3] ← T[1] + T[2] : lit T[1] \(=\) 4, T[2] \(=\) 7 ; la case T[3] reçoit 11.

Lecture. Ligne 5 : i reçoit 3.

Lecture. Ligne 6 : T[i + 1] ← T[i] × 2 : lit T[3] \(=\) 11 ; la case T[4] reçoit 22.

Lecture. Ligne 7 : Écrire écrit « 7 22 » (cases lues : T[2] \(=\) 7, T[4] \(=\) 22). Lire une case ne la modifie pas ; l’écrire remplace sa valeur.

Le remplissage par Lire, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Entrée au clavier : 4 ; 12 ; 8 ; 15 ; 9

Écrit par Écrire \(\rightarrow\)

dernière case : 9

Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 4.

Lecture. Ligne 2 : déclaration de T, tableau de 4 entiers d’indices 1 à 4 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 1 ; la valeur tapée, 12, est rangée dans la case T[1].

Lecture. Ligne 3 : Pour augmente i : 2 ; test 2 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 2 ; la valeur tapée, 8, est rangée dans la case T[2].

Lecture. Ligne 3 : Pour augmente i : 3 ; test 3 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 3 ; la valeur tapée, 15, est rangée dans la case T[3].

Lecture. Ligne 3 : Pour augmente i : 4 ; test 4 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 4 ; la valeur tapée, 9, est rangée dans la case T[4].

Lecture. Ligne 3 : Pour augmente i : 5 ; test 5 ≤ 4 : faux ; fin du Pour ; suite à la ligne 6.

Lecture. Ligne 6 : Écrire écrit « dernière case : 9 » (cases lues : T[4] \(=\) 9). Une case remplie par tour, dans l’ordre des indices.

La somme et la moyenne, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

58 11,6

Lecture. Ligne 1 : n reçoit 5.

Lecture. Ligne 2 : déclaration de T, tableau de 5 entiers d’indices 1 à 5 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 5 valeurs, dans l’ordre des indices : T[1] \(=\) 12, T[2] \(=\) 8, T[3] \(=\) 15, T[4] \(=\) 9, T[5] \(=\) 14.

Lecture. Ligne 4 : s reçoit 0.

Lecture. Ligne 5 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : s ← s + T[i] : lit T[1] \(=\) 12 ; s passe de 0 à 12.

Lecture. Ligne 5 : Pour augmente i : 2 ; test 2 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : s ← s + T[i] : lit T[2] \(=\) 8 ; s passe de 12 à 20.

Lecture. Ligne 5 : Pour augmente i : 3 ; test 3 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : s ← s + T[i] : lit T[3] \(=\) 15 ; s passe de 20 à 35.

Lecture. Ligne 5 : Pour augmente i : 4 ; test 4 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : s ← s + T[i] : lit T[4] \(=\) 9 ; s passe de 35 à 44.

Lecture. Ligne 5 : Pour augmente i : 5 ; test 5 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : s ← s + T[i] : lit T[5] \(=\) 14 ; s passe de 44 à 58.

Lecture. Ligne 5 : Pour augmente i : 6 ; test 6 ≤ 5 : faux ; fin du Pour ; suite à la ligne 8.

Lecture. Ligne 8 : moy reçoit s / n, soit 11,6.

Lecture. Ligne 9 : Écrire écrit « 58 11,6 ». \(s=12+8+15+9+14=58\) ; \(58/5=11{,}6\), un réel.

Le comptage, pas à pas : les notes d’au moins 10

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

au moins 10 : 3

Lecture. Ligne 1 : n reçoit 5.

Lecture. Ligne 2 : déclaration de T, tableau de 5 entiers d’indices 1 à 5 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 5 valeurs, dans l’ordre des indices : T[1] \(=\) 12, T[2] \(=\) 8, T[3] \(=\) 15, T[4] \(=\) 9, T[5] \(=\) 14.

Lecture. Ligne 4 : c reçoit 0.

Lecture. Ligne 5 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i] ≥ 10, soit 12 ≥ 10 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 7 : c ← c + 1 ; c passe de 0 à 1.

Lecture. Ligne 5 : Pour augmente i : 2 ; test 2 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i] ≥ 10, soit 8 ≥ 10 : faux ; le bloc est sauté.

Lecture. Ligne 5 : Pour augmente i : 3 ; test 3 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i] ≥ 10, soit 15 ≥ 10 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 7 : c ← c + 1 ; c passe de 1 à 2.

Lecture. Ligne 5 : Pour augmente i : 4 ; test 4 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i] ≥ 10, soit 9 ≥ 10 : faux ; le bloc est sauté.

Lecture. Ligne 5 : Pour augmente i : 5 ; test 5 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i] ≥ 10, soit 14 ≥ 10 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 7 : c ← c + 1 ; c passe de 2 à 3.

Lecture. Ligne 5 : Pour augmente i : 6 ; test 6 ≤ 5 : faux ; fin du Pour ; suite à la ligne 10.

Lecture. Ligne 10 : Écrire écrit « au moins 10 : 3 ». Cases 1, 3 et 5 (12, 15, 14) : 3 notes d’au moins 10.

Quoi, pourquoi, quand ça échoue : le parcours

Quoi

Un parcours est une boucle Pour \(i\) de 1 à \(n\) dont le compteur sert d’indice : le tour \(i\) traite la case T[i]. Chaque case est visitée une fois, dans l’ordre des indices, en \(n\) tours. Remplir, sommer, compter, chercher le maximum sont des parcours.

Pourquoi une boucle Pour

Le nombre de tours, \(n\), est connu avant d’entrer dans la boucle. L’en-tête fait varier l’indice : aucune case n’est sautée, aucune n’est visitée deux fois. Les compteurs et les accumulateurs de la Séance 3 s’initialisent avant la boucle et se mettent à jour à chaque case.

Quand ça échoue

Bornes décalées : de 1 à \(n-1\) oublie la dernière case ; de 0 à \(n-1\) ou de 1 à \(n+1\) demande une case qui n’existe pas (section 5). Accumulateur initialisé dans le corps : il ne garde que la dernière case.

Exercice : compter et sommer dans un tableau

n ← 6
P : tableau[1..n] d'entiers
P ← [0, 12, 5, 0, 30, 8]
nb ← 0
total ← 0
Pour j de 1 à n Faire
  Si P[j] > 0 Alors
    nb ← nb + 1
    total ← total + P[j]
  FinSi
FinPour
Écrire nb, total, total / nb

Pluie (mm) à Ziguinchor, six jours

  1. Relever, par tour : P[j], test l. 7, nb, total.
  2. Qu’écrit la ligne 12 ?
  3. Exécutions des lignes 7 et 8 ?
  4. Et si les six cases valent 0 ?

Correction

\(j\) **P[j]** **P[j] \(>\) 0** nb total
1 0 faux 0 0
2 12 vrai 1 12
3 5 vrai 2 17
4 0 faux 2 17
5 30 vrai 3 47
6 8 vrai 4 55
  1. nb et total ne changent qu’aux jours de pluie ; les jours 1 et 4 ne changent rien.
  2. 4 55 13,75 : \(55/4=13{,}75\) mm par jour de pluie.
  3. Ligne 7 : 6 fois, une par tour ; ligne 8 : 4 fois, une par test vrai.
  4. nb reste 0 et total / nb est une division par zéro : arrêt à la ligne 12. Tester \(\texttt{nb}>0\) avant de diviser.

La recherche d’un élément avec arrêt

Arrêt dès que \(x\) est trouvé : le nombre de tours n’est pas connu à l’entrée, d’où TantQue.

Recherche séquentielle avec arrêt

Comparer \(x\) aux cases 1, 2, 3… tant que \(i\leq n\) et \(\texttt{pos}=0\) ; pos : première case égale à \(x\), ou 0 si absent.

Lecture. Cases comparées pour \(x=15\) en orange. Présent à la case \(k\) : \(k\) comparaisons ; absent : \(n\).

La recherche avec arrêt, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Entrée au clavier : 15

Écrit par Écrire \(\rightarrow\)

case : 3

Lecture. Ligne 1 : n reçoit 5.

Lecture. Ligne 2 : déclaration de T, tableau de 5 entiers d’indices 1 à 5 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 5 valeurs, dans l’ordre des indices : T[1] \(=\) 12, T[2] \(=\) 8, T[3] \(=\) 15, T[4] \(=\) 9, T[5] \(=\) 14.

Lecture. Ligne 4 : Lire x ; l’entrée au clavier donne x \(=\) 15.

Lecture. Ligne 5 : pos reçoit 0.

Lecture. Ligne 6 : i reçoit 1.

Lecture. Ligne 7 : test i ≤ n ET pos = 0, soit 1 ≤ 5 ET 0 = 0 : vrai ; le corps est exécuté.

Lecture. Ligne 8 : test du Si, T[i] = x, soit 12 = 15 : faux ; le bloc est sauté.

Lecture. Ligne 11 : i ← i + 1 ; i passe de 1 à 2.

Lecture. Ligne 7 : test i ≤ n ET pos = 0, soit 2 ≤ 5 ET 0 = 0 : vrai ; le corps est exécuté.

Lecture. Ligne 8 : test du Si, T[i] = x, soit 8 = 15 : faux ; le bloc est sauté.

Lecture. Ligne 11 : i ← i + 1 ; i passe de 2 à 3.

Lecture. Ligne 7 : test i ≤ n ET pos = 0, soit 3 ≤ 5 ET 0 = 0 : vrai ; le corps est exécuté.

Lecture. Ligne 8 : test du Si, T[i] = x, soit 15 = 15 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 9 : pos ← i ; pos passe de 0 à 3.

Lecture. Ligne 11 : i ← i + 1 ; i passe de 3 à 4.

Lecture. Ligne 7 : test i ≤ n ET pos = 0, soit 4 ≤ 5 ET 3 = 0 : faux ; la boucle s’arrête ; suite à la ligne 13.

Lecture. Ligne 13 : Écrire écrit « case : 3 ». 3 cases comparées au lieu de 5 ; 0 n’est pas un indice.

Le maximum et sa position, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

38 4

Lecture. Ligne 1 : n reçoit 5.

Lecture. Ligne 2 : déclaration de T, tableau de 5 entiers d’indices 1 à 5 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 5 valeurs, dans l’ordre des indices : T[1] \(=\) 31, T[2] \(=\) 35, T[3] \(=\) 33, T[4] \(=\) 38, T[5] \(=\) 36.

Lecture. Ligne 4 : maxi reçoit T[1], soit 31 (case lue : T[1] \(=\) 31).

Lecture. Ligne 5 : pos reçoit 1.

Lecture. Ligne 6 : Pour donne à i sa première valeur, 2 ; test 2 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 7 : test du Si, T[i] > maxi, soit 35 > 31 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 8 : maxi ← T[i] : lit T[2] \(=\) 35 ; maxi passe de 31 à 35.

Lecture. Ligne 9 : pos ← i ; pos passe de 1 à 2.

Lecture. Ligne 6 : Pour augmente i : 3 ; test 3 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 7 : test du Si, T[i] > maxi, soit 33 > 35 : faux ; le bloc est sauté.

Lecture. Ligne 6 : Pour augmente i : 4 ; test 4 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 7 : test du Si, T[i] > maxi, soit 38 > 35 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 8 : maxi ← T[i] : lit T[4] \(=\) 38 ; maxi passe de 35 à 38.

Lecture. Ligne 9 : pos ← i ; pos passe de 2 à 4.

Lecture. Ligne 6 : Pour augmente i : 5 ; test 5 ≤ 5 : vrai ; un tour du corps.

Lecture. Ligne 7 : test du Si, T[i] > maxi, soit 36 > 38 : faux ; le bloc est sauté.

Lecture. Ligne 6 : Pour augmente i : 6 ; test 6 ≤ 5 : faux ; fin du Pour ; suite à la ligne 12.

Lecture. Ligne 12 : Écrire écrit « 38 4 ». Départ sur T[1] ; le test strict garde la première position.

Quoi, pourquoi, quand ça échoue : la recherche

Quoi

Deux conditions d’arrêt, liées par ET : \(i\leq n\) (il reste des cases) et \(\texttt{pos}=0\) (rien n’est encore trouvé). La boucle s’arrête dès que l’une devient fausse ; pos dit alors laquelle.

Pourquoi T{[i]} n’est lue que dans le corps

Le corps n’est exécuté qu’après un test \(i\leq n\) vrai : T[i] y désigne toujours une case qui existe. Le maximum suit la même idée : maxi part de T[1], une donnée, et la boucle commence à 2.

Quand ça échoue

TantQue \(i\leq n\) ET T[i] \(\neq x\) : quand \(x\) est absent, le dernier test, avec \(i=n+1\), lit T[n + 1] : les deux membres d’un ET sont évalués. Oublier \(i\leftarrow i+1\) : boucle infinie dès que T[1] \(\neq x\).

Exercice : le minimum et sa position

n ← 5
T : tableau[1..n] d'entiers
T ← [700, 500, 900, 500, 600]
mini ← T[1]
pos ← 1
Pour i de 2 à n Faire
  Si T[i] < mini Alors
    mini ← T[i]
    pos ← i
  FinSi
FinPour
Écrire mini, pos

Prix du kilo (F), marché Tilène

  1. Relever, par tour : T[i], test l. 7, mini, pos.
  2. Qu’écrit la ligne 12 ?
  3. Et avec T[i] \(\leq\) mini à la ligne 7 ?
  4. Comparaisons de la ligne 7 pour \(n\) cases ?

Correction

\(i\) **T[i]** **T[i] \(<\) mini** mini pos
2 500 vrai 500 2
3 900 faux 500 2
4 500 faux 500 2
5 600 faux 500 2
  1. mini part de T[1] \(=700\) ; un seul test vrai, à la case 2.
  2. 500 2 : le prix le plus bas et la première vendeuse qui le pratique.
  3. Au tour 4, \(500\leq500\) est vrai : pos passe à 4 et la ligne 12 écrit 500 4, la dernière position du minimum.
  4. \(n-1\), une par tour (ici 4) : la case 1 sert d’initialisation.

L’inversion d’un tableau, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

(rien)

Lecture. Ligne 1 : n reçoit 5.

Lecture. Ligne 2 : déclaration de T, tableau de 5 entiers d’indices 1 à 5 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 5 valeurs, dans l’ordre des indices : T[1] \(=\) 4, T[2] \(=\) 9, T[3] \(=\) 2, T[4] \(=\) 7, T[5] \(=\) 5.

Lecture. Ligne 4 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 5 div 2, soit 1 ≤ 2 : vrai ; un tour du corps.

Lecture. Ligne 5 : tmp reçoit T[i], soit 4 (case lue : T[1] \(=\) 4).

Lecture. Ligne 6 : T[i] ← T[n - i + 1] : lit T[5] \(=\) 5 ; la case T[1] passe de 4 à 5.

Lecture. Ligne 7 : T[n - i + 1] ← tmp ; la case T[5] passe de 5 à 4.

Lecture. Ligne 4 : Pour augmente i : 2 ; test 2 ≤ 5 div 2, soit 2 ≤ 2 : vrai ; un tour du corps.

Lecture. Ligne 5 : tmp ← T[i] : lit T[2] \(=\) 9 ; tmp passe de 4 à 9.

Lecture. Ligne 6 : T[i] ← T[n - i + 1] : lit T[4] \(=\) 7 ; la case T[2] passe de 9 à 7.

Lecture. Ligne 7 : T[n - i + 1] ← tmp ; la case T[4] passe de 7 à 9.

Lecture. Ligne 4 : Pour augmente i : 3 ; test 3 ≤ 5 div 2, soit 3 ≤ 2 : faux ; fin du Pour ; l’algorithme est terminé. T[3] ne bouge pas.

Le décalage circulaire vers la droite, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

(rien)

Lecture. Ligne 1 : n reçoit 5.

Lecture. Ligne 2 : déclaration de T, tableau de 5 entiers d’indices 1 à 5 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 5 valeurs, dans l’ordre des indices : T[1] \(=\) 4, T[2] \(=\) 9, T[3] \(=\) 2, T[4] \(=\) 7, T[5] \(=\) 5.

Lecture. Ligne 4 : der reçoit T[n], soit 5 (case lue : T[5] \(=\) 5).

Lecture. Ligne 5 : Pour donne à i sa première valeur, 5 ; test 5 ≥ 2 : vrai ; un tour du corps.

Lecture. Ligne 6 : T[i] ← T[i - 1] : lit T[4] \(=\) 7 ; la case T[5] passe de 5 à 7.

Lecture. Ligne 5 : Pour diminue i : 4 ; test 4 ≥ 2 : vrai ; un tour du corps.

Lecture. Ligne 6 : T[i] ← T[i - 1] : lit T[3] \(=\) 2 ; la case T[4] passe de 7 à 2.

Lecture. Ligne 5 : Pour diminue i : 3 ; test 3 ≥ 2 : vrai ; un tour du corps.

Lecture. Ligne 6 : T[i] ← T[i - 1] : lit T[2] \(=\) 9 ; la case T[3] passe de 2 à 9.

Lecture. Ligne 5 : Pour diminue i : 2 ; test 2 ≥ 2 : vrai ; un tour du corps.

Lecture. Ligne 6 : T[i] ← T[i - 1] : lit T[1] \(=\) 4 ; la case T[2] passe de 9 à 4.

Lecture. Ligne 5 : Pour diminue i : 1 ; test 1 ≥ 2 : faux ; fin du Pour ; suite à la ligne 8.

Lecture. Ligne 8 : T[1] ← der ; la case T[1] passe de 4 à 5. Le compteur descend : chaque case est lue avant d’être écrasée.

Exercice : la borne d’une inversion

n ← 4
T : tableau[1..n] d'entiers
T ← [2, 4, 6, 8]
Pour i de 1 à n Faire
  tmp ← T[i]
  T[i] ← T[n - i + 1]
  T[n - i + 1] ← tmp
FinPour

Énoncé

  1. Donner le contenu de T après chaque tour.
  2. Que contient T à la fin ? Pourquoi ?
  3. Corriger la ligne 4 ; combien de tours pour \(n=4\), pour \(n=5\) ?
  4. Pour \(n=5\), quelle case ne bouge pas ?

Correction

\(i\) échange **T après le tour**
1 cases 1 et 4 8 4 6 2
2 cases 2 et 3 8 6 4 2
3 cases 3 et 2 8 4 6 2
4 cases 4 et 1 2 4 6 8
  1. Le tour \(i\) échange les cases \(i\) et \(n-i+1\).
  2. 2 4 6 8, l’état de départ : les tours 3 et 4 refont, en sens inverse, les échanges des tours 1 et 2.
  3. Pour \(i\) de 1 à \(n\) div 2 : 2 tours pour \(n=4\) et pour \(n=5\).
  4. T[3], la case du milieu : \(n-3+1=3\), elle serait échangée avec elle-même.

L’indice hors bornes, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Écrit par Écrire \(\rightarrow\)

arrêt : T[5] hors bornes

Lecture. Ligne 1 : n reçoit 4.

Lecture. Ligne 2 : déclaration de T, tableau de 4 entiers d’indices 1 à 4 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : T reçoit ses 4 valeurs, dans l’ordre des indices : T[1] \(=\) 31, T[2] \(=\) 35, T[3] \(=\) 33, T[4] \(=\) 38.

Lecture. Ligne 4 : c reçoit 0.

Lecture. Ligne 5 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i + 1] > T[i], soit 35 > 31 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 7 : c ← c + 1 ; c passe de 0 à 1.

Lecture. Ligne 5 : Pour augmente i : 2 ; test 2 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i + 1] > T[i], soit 33 > 35 : faux ; le bloc est sauté.

Lecture. Ligne 5 : Pour augmente i : 3 ; test 3 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 6 : test du Si, T[i + 1] > T[i], soit 38 > 33 : vrai ; le bloc Alors est exécuté.

Lecture. Ligne 7 : c ← c + 1 ; c passe de 1 à 2.

Lecture. Ligne 5 : Pour augmente i : 4 ; test 4 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 6 : T[i + 1] désigne T[5], qui n’existe pas (indices 1 à 4) : indice hors bornes, arrêt. La borne correcte est \(n-1\).

Le tableau non rempli, pas à pas

Tableau d’état : les 8 derniers pas ; case lue : orange ; case écrite : rouge.

Entrée au clavier : 4 ; 12 ; 8 ; 15

Écrit par Écrire \(\rightarrow\)

arrêt : T[4] non remplie

Lecture. Ligne 1 : Lire n ; l’entrée au clavier donne n \(=\) 4.

Lecture. Ligne 2 : déclaration de T, tableau de 4 entiers d’indices 1 à 4 ; ses cases ne sont pas encore remplies.

Lecture. Ligne 3 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 4 - 1, soit 1 ≤ 3 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 1 ; la valeur tapée, 12, est rangée dans la case T[1].

Lecture. Ligne 3 : Pour augmente i : 2 ; test 2 ≤ 4 - 1, soit 2 ≤ 3 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 2 ; la valeur tapée, 8, est rangée dans la case T[2].

Lecture. Ligne 3 : Pour augmente i : 3 ; test 3 ≤ 4 - 1, soit 3 ≤ 3 : vrai ; un tour du corps.

Lecture. Ligne 4 : Lire T[i] avec i \(=\) 3 ; la valeur tapée, 15, est rangée dans la case T[3].

Lecture. Ligne 3 : Pour augmente i : 4 ; test 4 ≤ 4 - 1, soit 4 ≤ 3 : faux ; fin du Pour ; suite à la ligne 6.

Lecture. Ligne 6 : s reçoit 0.

Lecture. Ligne 7 : Pour donne à i sa première valeur, 1 ; test 1 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 8 : s ← s + T[i] : lit T[1] \(=\) 12 ; s passe de 0 à 12.

Lecture. Ligne 7 : Pour augmente i : 2 ; test 2 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 8 : s ← s + T[i] : lit T[2] \(=\) 8 ; s passe de 12 à 20.

Lecture. Ligne 7 : Pour augmente i : 3 ; test 3 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 8 : s ← s + T[i] : lit T[3] \(=\) 15 ; s passe de 20 à 35.

Lecture. Ligne 7 : Pour augmente i : 4 ; test 4 ≤ 4 : vrai ; un tour du corps.

Lecture. Ligne 8 : T[i] désigne T[4], jamais remplie : valeur non définie, arrêt. La première boucle s’arrête à \(n-1\).

Quoi, pourquoi, quand ça échoue : les erreurs d’indice

Quoi

Un indice hors bornes désigne une case qui n’existe pas : T[k] avec \(k<1\) ou \(k>n\). Une case non remplie est lue avant d’avoir reçu une valeur. Les deux rendent l’algorithme faux ; selon le langage, l’exécution s’arrête ou utilise une valeur quelconque.

Pourquoi elles apparaissent aux bornes

L’indice est calculé (\(i+1\), \(i-1\), \(n-i+1\)) : sa valeur sort de 1 à \(n\) au premier ou au dernier tour. Vérifier chaque accès avec la première et la dernière valeur du compteur : \(i=n\) dans T[i + 1] donne \(n+1\).

Quand ça échoue

Indices pris de 0 à \(n-1\) : T[0] n’existe pas et T[n] est oubliée. Remplissage jusqu’à \(n-1\), puis parcours jusqu’à \(n\) : la dernière case est lue sans avoir été écrite.

À retenir

traitement boucle tours point de vigilance
somme, comptage Pour \(i\) de 1 à \(n\) \(n\) accumulateur, compteur initialisés avant
recherche avec arrêt TantQue \(i\leq n\) ET \(\texttt{pos}=0\) 1 à \(n\) \(\texttt{pos}=0\) : absent ; T[i] lue dans le corps
maximum, position Pour \(i\) de 2 à \(n\) \(n-1\) départ T[1] ; \(>\) : première position
inversion Pour \(i\) de 1 à \(n\) div 2 \(n\) div 2 échange par une variable auxiliaire
décalage vers la droite Pour \(i\) de \(n\) à 2 pas \(-1\) \(n-1\) de la dernière case vers la première

À retenir

  • Un tableau a \(n\) cases d’indices 1 à \(n\) ; T[i] est la case dont l’indice vaut \(i\).
  • Parcourir un tableau, c’est une boucle sur ses indices ; une recherche avec arrêt est un TantQue.
  • Indice hors bornes, case non remplie : deux erreurs à chercher aux tours extrêmes (\(i=1\), \(i=n\)).

Prochaine séance

Séance 5 — Les fonctions et procédures

Le maximum, la recherche ou l’inversion se réécrivent pour chaque tableau. Une fonction les écrit une fois, sous un nom, avec des paramètres (le tableau et sa taille) et une valeur de retour (la position trouvée) ; l’algorithme principal les appelle.

À préparer : refaire à la main les traces de la recherche avec arrêt et du maximum avec d’autres valeurs, dont une valeur absente.

Références

  • Cormen — Algorithms Unlocked, MIT Press, 2013 (ch. 2, « How to Describe and Evaluate Computer Algorithms » : recherche dans un tableau \(A[1..n]\)).
  • Cormen, Leiserson, Rivest, Stein — Introduction to Algorithms, 4e éd., MIT Press, 2022 (ch. 2, « Getting Started », § 2.1 : tableaux \(A[1:n]\), recherche linéaire en exercice).
  • Bhargava — Grokking Algorithms, 2e éd., Manning, 2024 (ch. 2, « Selection Sort » : tableaux).
  • Notes de cours en ligne : CS50 (Harvard), 6.100A (MIT), CS106A (Stanford), séances sur les tableaux.