Aller au contenu

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

Coût d'un algorithme : exercices corrigés de Première NSI

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

L'essentiel

  • Le coût en temps d'un algorithme se mesure en comptant des opérations élémentaires choisies ; le coût en espace, c'est la mémoire maximale utilisée en même temps. 6
  • On exprime le coût en fonction de la taille de l'entrée, souvent dans le cas le plus défavorable, mais aussi dans le cas le plus favorable ou en moyenne. 6
  • Un coût linéaire double quand la taille double ; la recherche dichotomique dans un tableau trié a un coût logarithmique. 32
  • Si la longueur l vérifie l ≤ 2^n, la dichotomie fait au plus n itérations. 3
  • Un algorithme glouton ne garantit pas toujours la solution optimale, même s'il est peu coûteux. 4

Comment utiliser ces exercices

Ces exercices t'entraînent à mesurer ce que coûte un algorithme, puis à comparer plusieurs algorithmes entre eux. Ils sont classés du plus simple au plus délicat. Essaie toujours de chercher seul avant d'ouvrir un indice, puis lis la correction pas à pas : une étape correspond à une action que tu peux refaire sur un autre exemple.

Tu as déjà rencontré des algorithmes comme les tris par insertion et par sélection, la recherche dichotomique, les algorithmes gloutons et les k plus proches voisins. Ici, tu ne les programmes pas : tu les observes comme un comptable, en regardant combien d'opérations ils demandent.

Les exercices

Exercice 1 Compter les comparaisons d'une recherche de maximum

★☆☆Environ 5 min

Voici une fonction qui renvoie le plus grand élément d'un tableau non vide.

def maximum(tab):
    m = tab[0]
    for x in tab:
        if x > m:
            m = x
    return m

On choisit de compter uniquement les comparaisons x > m. Combien de comparaisons la fonction effectue-t-elle pour un tableau de 250 éléments ? Le résultat dépend-il du contenu du tableau ?

Indice 1

La boucle for x in tab parcourt chaque élément, y compris le premier.

Indice 2

Le test est exécuté une fois par passage dans la boucle, que la condition soit vraie ou non.

Voir la correction pas à pas
  1. On choisit l'opération à compter : ici, la comparaison x > m, comme l'énoncé le précise. 6

  2. On repère la taille de l'entrée : le tableau contient 250 éléments.

  3. On regarde la boucle : elle fait un passage par élément, donc 250 passages.

  4. À chaque passage, il y a exactement une comparaison, que le test soit vrai ou faux : on obtient 250 comparaisons.

  5. On répond à la seconde question : le nombre de comparaisons ne dépend pas du contenu du tableau, seulement de sa longueur. Les affectations m = x, elles, dépendent du contenu, mais on ne les compte pas ici.

La fonction effectue 250 comparaisons, quel que soit le contenu du tableau. Son coût en temps est proportionnel à la taille de l'entrée : on parle de coût linéaire.

Exercice 2 Quand la taille quadruple

★☆☆Environ 5 min

Une recherche séquentielle dans une liste non triée a une complexité linéaire : le temps de recherche double quand la longueur de la liste double. 3

Sur une liste de 1 000 éléments, la recherche prend 3 ms dans le cas défavorable. Combien de temps prendra-t-elle, dans le même cas, sur une liste de 4 000 éléments, sur la même machine ?

Indice 1

Si le temps double quand la longueur double, que se passe-t-il quand elle quadruple ?

Indice 2

Le temps est proportionnel à la longueur : tu peux écrire une règle de trois.

Voir la correction pas à pas
  1. On identifie le type de coût : linéaire, donc le temps est proportionnel à la longueur. 3

  2. On calcule le rapport des tailles : 4 000 divisé par 1 000 donne 4.

  3. On applique le même rapport au temps : 3 ms multipliées par 4 donnent 12 ms.

  4. On vérifie la cohérence : 2 000 éléments donneraient 6 ms (double), et 4 000 éléments le double de 6 ms, soit 12 ms.

La recherche prendra 12 ms. Un coût linéaire se reconnaît à cette proportionnalité : multiplier la taille par k multiplie le temps par k.

Exercice 3 Combien d'itérations pour une dichotomie ?

★★☆Environ 10 min

La recherche dichotomique permet de chercher un élément dans un tableau trié en temps logarithmique. 2 On sait aussi que, si l'entier n vérifie l ≤ 2^n, où l est la longueur du tableau, alors l'algorithme effectue au plus n itérations. 3

On dispose d'un tableau trié de 1 000 000 d'éléments. Quel est le plus petit entier n qui convient, c'est-à-dire le nombre maximal d'itérations garanti par ce raisonnement ? Compare ensuite avec le nombre de comparaisons d'une recherche séquentielle dans le pire des cas.

Indice 1

Cherche la plus petite puissance de 2 supérieure ou égale à 1 000 000.

Indice 2

Tu sais que 2^10 = 1 024, donc 2^20 = 1 024 × 1 024.

Voir la correction pas à pas
  1. On écrit la condition à satisfaire : 1 000 000≤2n1\,000\,000 \le 2^n. 3

  2. On encadre : 210=1 0242^{10} = 1\,024, donc 220=1 0242=1 048 5762^{20} = 1\,024^2 = 1\,048\,576.

  3. On compare : 219=524 2882^{19} = 524\,288 est inférieur à 1 000 000, donc 19 ne convient pas ; 220=1 048 5762^{20} = 1\,048\,576 est supérieur, donc 20 convient.

  4. On conclut : le plus petit n est 20, donc au plus 20 itérations.

  5. On compare avec la recherche séquentielle : dans le pire des cas, il faut parcourir tout le tableau, soit 1 000 000 de comparaisons, contre 20 itérations pour la dichotomie.

Le plus petit entier n est 20. Passer de un million d'éléments à vingt itérations montre l'écart entre un coût linéaire et un coût logarithmique. Attention : la dichotomie n'est valable que si le tableau est trié.

Exercice 4 Deux boucles imbriquées

★★☆Environ 10 min

On considère la fonction suivante, où tab contient 40 éléments.

def paires(tab):
    compteur = 0
    for i in range(len(tab)):
        for j in range(i):
            compteur = compteur + 1
    return compteur

On compte le nombre de fois où l'instruction compteur = compteur + 1 est exécutée. Quelle valeur la fonction renvoie-t-elle ? Que deviendrait ce nombre si la taille du tableau doublait (80 éléments) : double-t-il ?

Indice 1

Pour une valeur donnée de i, la boucle intérieure fait exactement i passages.

Indice 2

Il faut additionner 0 + 1 + 2 + ... + 39. Pense à la somme des premiers entiers : n(n+1)2\frac{n(n+1)}{2}.

Voir la correction pas à pas
  1. On repère les deux boucles : i prend les valeurs de 0 à 39, et pour chaque i, j prend les valeurs de 0 à i − 1, soit i passages.

  2. On écrit le total : 0+1+2+⋯+390 + 1 + 2 + \dots + 39.

  3. On applique la formule de la somme des entiers de 1 à 39 : 39×402=780\frac{39 \times 40}{2} = 780. Le terme 0 n'ajoute rien.

  4. On refait le calcul pour 80 éléments : 0+1+⋯+79=79×802=3 1600 + 1 + \dots + 79 = \frac{79 \times 80}{2} = 3\,160.

  5. On compare : 3 160 divisé par 780 vaut un peu plus de 4. Le coût a été multiplié par environ 4 quand la taille a doublé : il n'est pas linéaire.

La fonction renvoie 780. Avec deux boucles imbriquées dépendant de la taille, le coût croît bien plus vite que la taille : doubler l'entrée multiplie le coût par environ quatre.

Exercice 5 Le glouton face au rendu de monnaie

★★☆Environ 10 min

Un système de pièces a pour valeurs faciales : [30, 24, 12, 6, 3, 1]. 4 L'algorithme glouton paie d'abord avec la plus grosse pièce possible. Pour payer 48, il répond 48 = 30 + 12 + 6. 4

Une réponse optimale est celle qui utilise le nombre minimal de pièces. 4 Trouve une façon de payer 48 avec moins de pièces que le glouton, puis donne la différence entre le nombre de pièces du glouton et le nombre minimal de pièces.

Indice 1

Le glouton choisit 30 tout de suite. Que se passe-t-il si tu évites cette pièce ?

Indice 2

Regarde si 48 est un multiple d'une des valeurs de la liste.

Voir la correction pas à pas
  1. On compte les pièces du glouton : 30 + 12 + 6 donne trois pièces. 4

  2. On cherche mieux : 48 = 24 × 2, soit 24 + 24, deux pièces.

  3. On vérifie qu'on ne peut pas faire avec une seule pièce : la plus grande pièce vaut 30, qui est inférieur à 48, donc une seule pièce ne suffit pas. Le minimum est donc 2.

  4. On calcule la différence : 3 − 2 = 1 pièce de moins.

L'optimal est 24 + 24, avec 2 pièces, contre 3 pour le glouton : une pièce d'écart. Cet exemple montre qu'un algorithme glouton n'est pas garanti d'être optimal en général. 4

Exercice 6 Coût moyen d'une recherche séquentielle

★★★Environ 15 min

On cherche une valeur dans une liste non triée de 200 éléments, en la parcourant de gauche à droite et en s'arrêtant dès qu'on trouve la valeur. On compte les comparaisons. On suppose que la valeur cherchée est présente, et qu'elle a la même probabilité de se trouver à chacune des 200 positions.

  1. Quel est le nombre de comparaisons dans le cas le plus favorable ? Dans le cas le plus défavorable ?
  2. Calcule le nombre moyen de comparaisons.
Indice 1

Si la valeur est en position k (en comptant à partir de 1), il faut exactement k comparaisons.

Indice 2

Le nombre moyen est la somme de toutes les valeurs possibles divisée par leur nombre : 1+2+⋯+200200\frac{1 + 2 + \dots + 200}{200}.

Voir la correction pas à pas
  1. On rappelle les trois mesures possibles : cas le plus défavorable, cas le plus favorable, coût moyen. 6

  2. Cas le plus favorable : la valeur est en première position, donc 1 comparaison.

  3. Cas le plus défavorable : la valeur est en dernière position, donc 200 comparaisons.

  4. Pour la moyenne, si la valeur est en position k, il faut k comparaisons. Chaque position a la probabilité 1200\frac{1}{200}.

  5. On calcule la somme : 1+2+⋯+200=200×2012=20 1001 + 2 + \dots + 200 = \frac{200 \times 201}{2} = 20\,100.

  6. On divise : 20 100200=100,5\frac{20\,100}{200} = 100{,}5 comparaisons en moyenne.

Le cas favorable coûte 1 comparaison, le défavorable 200, et la moyenne vaut 100,5, soit un peu plus de la moitié de la longueur. Une moyenne de l'ordre de la moitié de la taille reste proportionnelle à la taille : le coût reste linéaire.

Exercice 7 Temps ou mémoire : que choisir ?

★★★Environ 15 min

Deux fonctions calculent la somme des carrés des éléments d'une liste tab de n entiers.

def somme_a(tab):
    carres = []
    for x in tab:
        carres.append(x * x)
    total = 0
    for c in carres:
        total = total + c
    return total

def somme_b(tab):
    total = 0
    for x in tab:
        total = total + x * x
    return total
  1. Compare le nombre de multiplications effectuées par chaque fonction.
  2. Compare la mémoire supplémentaire utilisée, sans compter la liste tab elle-même.
  3. Laquelle préfères-tu et pourquoi ?
Indice 1

Regarde ce que contient la variable carres à la fin de la première boucle de somme_a.

Indice 2

Le coût spatial est la quantité maximale de mémoire utilisée simultanément.

Voir la correction pas à pas
  1. On choisit l'opération comptée : la multiplication x * x. 6

  2. Dans somme_a, la multiplication est faite une fois par élément dans la première boucle : n multiplications. Dans somme_b, elle est faite une fois par élément : n multiplications également. Le coût en temps est du même ordre.

  3. On examine la mémoire. Le coût spatial est la quantité maximale de mémoire utilisée en même temps. 6 somme_a stocke n valeurs dans carres, donc mémoire supplémentaire proportionnelle à n.

  4. somme_b ne conserve que la variable total (et la variable de boucle) : mémoire supplémentaire constante, quelle que soit la taille de la liste.

  5. On conclut : à coût en temps comparable, somme_b est préférable car elle utilise beaucoup moins de mémoire. somme_a ne se justifierait que si l'on avait besoin de réutiliser la liste des carrés.

Les deux fonctions font le même nombre de multiplications, mais somme_a demande une mémoire supplémentaire proportionnelle à n alors que somme_b n'en demande qu'une quantité constante. Le coût en temps et le coût en espace sont deux critères distincts, et il faut les examiner séparément.

Les questions qu'on se pose

Faut-il compter toutes les instructions pour trouver le coût d'un algorithme ?

Non. Les opérations élémentaires n'ont pas toutes le même coût, et chercher à toutes les compter est à la fois difficile et inutile. On sélectionne les opérations qui donnent un ordre de grandeur utile selon le contexte, par exemple les comparaisons dans une recherche ou un tri. 6 Dans un exercice, l'énoncé t'indique en général quelle opération compter ; sinon, choisis-la et dis-le clairement dans ta réponse.

Pourquoi parle-t-on de cas le plus défavorable, le plus favorable et de cas moyen ?

Parce que le coût d'un algorithme peut dépendre de l'instance et pas seulement de sa taille. L'objectif est pourtant d'évaluer le coût en fonction de la taille. On définit donc plusieurs mesures : le coût dans le cas le plus défavorable (la plus utilisée), dans le cas le plus favorable, ou le coût moyen. 6 Dans la recherche séquentielle de l'exercice sur le coût moyen, le cas favorable coûte 1 comparaison et le défavorable en coûte autant que d'éléments.

Sources

  1. Ressources d'accompagnement NSI Première - Page centrale, Éduscol. Consulté le 6 novembre 2026.
  2. Diviser pour régner - Document d'accompagnement, Éduscol. Consulté le 6 novembre 2026.
  3. Recherche dichotomique - Analyse de complexité, Éduscol. Consulté le 6 novembre 2026.
  4. Programmation dynamique - Étude de coût, Éduscol. Consulté le 6 novembre 2026.
  5. Sujets zéro du concours général NSI - Exemples d'algorithmes, Éduscol. Consulté le 6 novembre 2026.
  6. Analyse de la complexité des algorithmes, Wikipédia. Consulté le 6 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

Je suis en…

Primaire

  • CP Bientôt
  • CE1 Bientôt
  • CE2 Bientôt
  • CM1 Bientôt
  • CM2 Bientôt

Collège

Lycée

Supérieur

  • BTS Bientôt
  • BUT Bientôt
  • Licence Bientôt
  • Prépas Bientôt

Sur cette page