Numérique et sciences informatiques (spécialité) · Première

Parcours séquentiel d'un tableau : exercices de 1re NSI

Publié le 7 novembre 2026 · Mis à jour le 7 novembre 2026 · Signaler une erreur

L'essentiel

Parcourir un tableau séquentiellement, c'est examiner ses éléments un par un, de l'indice 0 à l'indice len(t) - 1.
Quatre schémas reviennent sans cesse : accumuler (somme, compteur), mémoriser (maximum, minimum), chercher avec arrêt, comparer deux voisins.
Pour un tableau de n éléments, le parcours complet demande environ n tours de boucle ; la recherche peut s'arrêter plus tôt.
Avant d'écrire du code, fais une trace : valeurs de l'indice et des variables à chaque tour.

Comment utiliser ces exercices

Ces exercices t'entraînent à écrire et à comprendre des boucles qui lisent un tableau du début à la fin. Ils sont classés par difficulté croissante. Commence par chercher seul, avec une feuille et un crayon, puis ouvre les indices un par un, et seulement ensuite la correction.

À retenirLes deux formes de parcours en Python

Parcours par indice :

for i in range(len(t)):
    # on utilise t[i] et on connaît i

Parcours par valeur :

for x in t:
    # on utilise x, mais on ne connaît plus l'indice

Choisis le parcours par indice dès que l'énoncé demande une position, ou que tu compares un élément à son voisin.

Rappel : les schémas de parcours

Un parcours séquentiel lit les éléments dans l'ordre des indices, sans en sauter. Dans les exercices classiques de programmation, une première boucle remplit un tableau et une seconde boucle le relit pour afficher ou calculer quelque chose ⁵. Ce que tu fais ici est la seconde partie : lire, et calculer en lisant.

Les exercices

Exercice 1 Somme des éléments

★☆☆Environ 5 min

On considère le tableau t = [4, 8, 15, 16, 23, 42].

Écris une boucle for par indice qui calcule la somme s des éléments de t.
Quelle est la valeur de s à la fin ?

Indice 1

Une somme se prépare avec une variable initialisée à 0 avant la boucle.

Indice 2

À chaque tour, on ajoute t[i] à s.

Voir la correction pas à pas

On initialise l'accumulateur : s = 0.
On écrit la boucle : for i in range(len(t)): s = s + t[i].
Trace des valeurs de s après chaque tour : 4, 12, 27, 43, 66, 108.
Après le dernier tour (i = 5), s vaut 108.

La somme vaut 108. Ce schéma d'accumulateur sert de base à la moyenne, au comptage et à bien d'autres calculs.

Exercice 2 Où se trouve le maximum ?

★☆☆Environ 8 min

Soit t = [12, 7, 19, 3, 19, 8].

On veut l'indice de la première case qui contient la valeur maximale.

Écris une boucle qui mémorise le maximum et son indice.
Donne l'indice obtenu.

Indice 1

Initialise m = t[0] et ind = 0, puis démarre la boucle à l'indice 1.

Indice 2

Pour obtenir la première occurrence, mets à jour seulement si t[i] > m, et non >=.

Voir la correction pas à pas

Initialisation : m = t[0] (soit 12) et ind = 0.
Boucle : for i in range(1, len(t)): puis if t[i] > m: m = t[i]; ind = i.
Trace : i = 1 (7, pas de changement) ; i = 2 (19 > 12, donc m = 19 et ind = 2) ; i = 3 (3, rien) ; i = 4 (19 n'est pas > 19, rien) ; i = 5 (8, rien).
Le maximum est 19 et son indice est 2.

L'indice cherché est 2. Avec >=, on aurait obtenu 4, c'est-à-dire la dernière occurrence.

Exercice 3 Moyenne de notes

★☆☆Environ 8 min

Les notes d'un élève sont rangées dans notes = [12, 15, 9, 18, 11].

Écris une fonction moyenne(t) qui renvoie la moyenne des éléments d'un tableau non vide.
Calcule la moyenne de notes.

Indice 1

Il faut la somme des éléments, puis une division par le nombre d'éléments.

Indice 2

Le nombre d'éléments s'obtient avec len(t).

Voir la correction pas à pas

On parcourt le tableau pour accumuler la somme : s = 0 puis for x in t: s = s + x.
On renvoie s / len(t), après la boucle et non dans la boucle.
Somme : 12 + 15 + 9 + 18 + 11 = 65.
Nombre de notes : 5, donc la moyenne est $\frac{65}{5} = 13$ .

La moyenne vaut 13. Ici le parcours par valeur suffit, car la position des notes ne sert à rien.

Exercice 4 Compter les occurrences

★★☆Environ 10 min

Soit t = [3, 1, 3, 3, 2, 1, 3].

Écris une fonction occurrences(t, v) qui renvoie le nombre de fois où la valeur v apparaît dans t.
Que renvoie occurrences(t, 3) ?

Indice 1

Utilise un compteur initialisé à 0, comme pour une somme.

Indice 2

Le compteur augmente de 1 seulement quand x == v.

Voir la correction pas à pas

Initialisation : c = 0.
Boucle : for x in t: puis, dans la boucle, if x == v: suivi de c = c + 1 (chaque instruction sur sa propre ligne, indentée).
Après la boucle : return c.
Trace pour v = 3 : les valeurs lues sont 3, 1, 3, 3, 2, 1, 3. Le compteur passe par 1, 1, 2, 3, 3, 3, 4.
La fonction renvoie 4.

occurrences(t, 3) renvoie 4. Le parcours est complet : on ne peut pas s'arrêter avant la fin, car une autre occurrence peut toujours suivre.

Exercice 5 Recherche avec arrêt

★★☆Environ 10 min

Soit t = [5, 9, 2, 7, 9, 4]. On écrit :

def cherche(t, v):
    for i in range(len(t)):
        if t[i] == v:
            return i
    return -1

Que renvoie cherche(t, 7) ?
Combien de comparaisons t[i] == v sont effectuées pour cherche(t, 7) ?

Indice 1

Dès que return i est exécuté, la fonction se termine.

Indice 2

Compte les tours de boucle effectivement réalisés, y compris celui qui trouve la valeur.

Voir la correction pas à pas

Tour i = 0 : on compare 5 et 7, différents.
Tour i = 1 : on compare 9 et 7, différents.
Tour i = 2 : on compare 2 et 7, différents.
Tour i = 3 : on compare 7 et 7, égaux. La fonction renvoie 3 et s'arrête.
Il y a eu 4 comparaisons (indices 0, 1, 2 et 3).

cherche(t, 7) renvoie 3, après 4 comparaisons. Le return -1 est placé après la boucle : il n'est atteint que si la valeur est absente.

Exercice 6 Compter les montées

★★☆Environ 12 min

Soit t = [2, 5, 1, 8, 3]. On exécute :

m = 0
for i in range(len(t) - 1):
    if t[i] < t[i + 1]:
        m = m + 1

Pourquoi la boucle s'arrête-t-elle à len(t) - 2 ?
Quelle est la valeur de m à la fin ?

Indice 1

Le test utilise t[i + 1] : quel est le plus grand i pour lequel cet indice existe ?

Indice 2

Fais une trace avec les couples (t[i], t[i + 1]).

Voir la correction pas à pas

Le tableau a 5 éléments, donc les indices vont de 0 à 4. range(4) donne i = 0, 1, 2, 3, ce qui garantit que i + 1 vaut au plus 4.
i = 0 : 2 < 5 vrai, m = 1.
i = 1 : 5 < 1 faux, m reste 1.
i = 2 : 1 < 8 vrai, m = 2.
i = 3 : 8 < 3 faux, m reste 2.
À la fin, m vaut 2.

La boucle s'arrête avant le dernier indice pour éviter de lire hors du tableau, et m vaut 2. Avec range(len(t)), Python aurait levé une erreur d'indice au dernier tour.

Exercice 7 Le tableau est-il trié ?

★★★Environ 15 min

On veut une fonction est_trie(t) qui renvoie True si les éléments sont rangés dans l'ordre croissant (au sens large : deux valeurs égales côte à côte sont acceptées), et False sinon.

Écris la fonction avec un parcours qui peut s'arrêter dès qu'un défaut est trouvé.
Teste-la sur [1, 3, 3, 7, 9] et sur [1, 4, 3, 8].
Que renvoie-t-elle pour le tableau vide [] ? Est-ce cohérent ?

Indice 1

Compare chaque élément à son voisin de droite : un seul couple dans le mauvais ordre suffit à répondre False.

Indice 2

Le return True se place après la boucle.

Voir la correction pas à pas

Fonction :

def est_trie(t):
    for i in range(len(t) - 1):
        if t[i] > t[i + 1]:
            return False
    return True

Test sur [1, 3, 3, 7, 9] : les couples (1, 3), (3, 3), (3, 7), (7, 9) respectent tous t[i] <= t[i + 1]. La boucle va jusqu'au bout et la fonction renvoie True.
Test sur [1, 4, 3, 8] : le couple (1, 4) est correct, puis (4, 3) donne 4 > 3. La fonction renvoie False au tour i = 1, sans lire la fin.
Tableau vide : range(-1) ne contient aucun entier, la boucle ne s'exécute pas et la fonction renvoie True. C'est cohérent, car aucun couple n'est dans le mauvais ordre.

Le test > (et non >=) autorise les doublons. Un tableau d'un seul élément ou vide est considéré comme trié, faute de couple à comparer.

Exercice 8 Coût d'un parcours

★★★Environ 10 min

Pour trouver le maximum d'un tableau de 1000 éléments, on initialise m = t[0], puis on parcourt les indices de 1 à 999 en comparant t[i] à m.

Combien de comparaisons sont faites, quel que soit le contenu du tableau ?
Pourquoi ce nombre ne dépend-il pas des valeurs ?
Si le tableau contenait 2000 éléments, que devient ce nombre ?

Indice 1

Compte les indices de 1 à 999 inclus.

Indice 2

Peut-on s'arrêter plus tôt, comme dans une recherche d'une valeur donnée ?

Voir la correction pas à pas

Les indices parcourus vont de 1 à 999, soit $1000 - 1 = 999$ valeurs, donc 999 comparaisons.
Pour être sûr d'avoir le maximum, il faut avoir vu chaque élément : la dernière case pourrait contenir la plus grande valeur. Aucun arrêt anticipé n'est possible.
Pour 2000 éléments, il y aurait $2000 - 1 = 1999$ comparaisons : le nombre de comparaisons double à peu près quand la taille double.

Il y a 999 comparaisons. On dit que le coût est proportionnel à la taille du tableau, ce qui prépare l'étude des tris et de la recherche dichotomique, où l'on cherche à faire mieux qu'un parcours complet.

Les questions qu'on se pose

Faut-il toujours utiliser range(len(t)) ?

Non. Si seule la valeur compte (somme, moyenne, comptage), for x in t est plus simple et évite les erreurs d'indice. Utilise range(len(t)) quand tu as besoin de la position, ou quand tu compares un élément à son voisin.

Pourquoi initialiser le maximum à t[0] plutôt qu'à 0 ?

Parce que le tableau peut contenir uniquement des nombres négatifs. Avec un maximum initialisé à 0, tu renverrais 0, qui n'est même pas dans le tableau. Avec t[0], la valeur de départ appartient toujours au tableau (qui doit être non vide).

Comment vérifier ma boucle sans ordinateur ?

Fais une trace : un tableau à deux colonnes ou plus, avec une ligne par tour de boucle, qui note l'indice i et la valeur de chaque variable après le tour. Vérifie aussi les cas limites : tableau d'un seul élément, élément cherché en première case, en dernière case, ou absent.

Sources

Programmes et ressources en numérique et sciences informatiques - voie générale, Éduscol. Consulté le 7 novembre 2026.
Vademecum Sciences numériques et technologie, Numérique et Sciences Informatiques, Éduscol. Consulté le 7 novembre 2026.
Ressources d'accompagnement - Algorithmique et programmation, Éduscol. Consulté le 7 novembre 2026.
Annexe 1 - Programme NSI Première (arrêté ministériel officiel), Ministère de l'Éducation nationale et de la Jeunesse. Consulté le 7 novembre 2026.
TD10 Algo 2006-2007 : Algorithmique et structures de données, CNRS - LiRIS (Laboratoire d'Informatique en Image et Systèmes d'information). Consulté le 7 novembre 2026.
Tableau associatif, Wikipédia. Consulté le 7 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Parcours séquentiel d'un tableau : exercices de 1re NSI

L'essentiel

Comment utiliser ces exercices

Rappel : les schémas de parcours

Les exercices

Exercice 1 Somme des éléments

Exercice 2 Où se trouve le maximum ?

Exercice 3 Moyenne de notes

Exercice 4 Compter les occurrences

Exercice 5 Recherche avec arrêt

Exercice 6 Compter les montées

Exercice 7 Le tableau est-il trié ?

Exercice 8 Coût d'un parcours

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur