$course$/QCM de NSI/Première/Complexité algorithmique Notion de complexité asymptotique, notation O, classes
classiques (constante, logarithmique, linéaire, quasi
linéaire, quadratique, exponentielle), calcul à partir
du code, comparaison expérimentale, échelle de
croissance.

]]> Complexité algorithmique — Q01 : Définition de la complexité Que mesure la complexité algorithmique ?

]]> Deux types de complexité : temporelle (nombre
d'opérations) et spatiale (mémoire utilisée).
En NSI Première, on s'intéresse surtout à la
complexité temporelle.

]]> 1.0 0.0 0 true true abc Le nombre de lignes de code source nécessaires pour écrire l'algorithme

]]> Erreur : la complexité algorithmique mesure
l'évolution des ressources (temps,
mémoire), pas la longueur du code.

]]> La quantité de ressources consommée selon la taille de l'entrée

]]> Bonne réponse : on étudie comment le coût
(temps de calcul, mémoire) évolue lorsque la
taille n de l'entrée grandit.

]]> Le temps d'exécution en secondes, mesuré sur une machine donnée

]]> Erreur : la complexité ne dépend ni de la
machine ni du langage. Elle compte des
opérations élémentaires en fonction de la
taille n, pas des secondes sur un ordinateur
particulier.

]]> La difficulté qu'a un lecteur humain à comprendre le code source

]]> C'est la « complexité cognitive », notion
différente, non quantifiée formellement en
NSI.

]]> Complexité algorithmique — Q02 : Notation O Que signifie l'écriture O(n) (« grand O de n ») ?

]]> O(n) caractérise une famille de fonctions qui
croissent au plus comme c × n pour une constante
c. C'est une notation d'ordre de grandeur.

]]> 1.0 0.0 0 true true abc L'algorithme effectue exactement n opérations

]]> Erreur : O(n) est une borne asymptotique,
pas un compte exact. L'algorithme peut faire
2n + 5 opérations, on note O(n).

]]> Le nombre d'opérations croît proportionnellement à n

]]> Bonne réponse : O(n) signifie « linéaire ».
Doubler n double approximativement le temps.
Les constantes et les termes d'ordre
inférieur sont ignorés.

]]> L'algorithme utilise exactement n octets de mémoire vive

]]> O(n) peut s'appliquer à la mémoire, mais ce
n'est pas une définition générale.

]]> L'algorithme se termine en moins de n secondes

]]> Erreur : O ne mesure pas un temps absolu mais
une proportion.

]]> Complexité algorithmique — Q03 : Classes classiques Parmi les complexités suivantes, laquelle est la
plus rapide asymptotiquement ?

]]> Hiérarchie classique (du plus rapide au plus
lent) : O(1) < O(log n) < O(n) < O(n log n) <
O(n²) < O(n³) < O(2ⁿ) < O(n!).

]]> 1.0 0.0 0 true true abc O(n²)

]]> Erreur : quadratique, l'une des plus lentes
dans cette liste.

]]> O(n log n)

]]> Bonne, mais pas la plus rapide.

]]> O(log n)

]]> Bonne réponse : logarithmique. Pour n = 10⁶,
log₂(n) ≈ 20. C'est la complexité de la
recherche dichotomique.

]]> O(n)

]]> Linéaire : plus rapide que quadratique mais
plus lente que logarithmique.

]]> Complexité algorithmique — Q04 : Boucle simple Quelle est la complexité de cette fonction en
fonction de n = len(liste) ?
def somme(liste):
    total = 0
    for x in liste:
        total += x
    return total

]]> Règle pratique : une boucle imbriquée 0 fois
→ O(1) ; 1 fois → O(n) ; 2 fois → O(n²) ; etc.

]]> 1.0 0.0 0 true true abc O(log n)

]]> Erreur : aucun mécanisme dichotomique ici.

]]> O(1)

]]> Erreur : la boucle dépend de la taille de
la liste.

]]> O(n)

]]> Bonne réponse : une boucle simple sur n
éléments avec une opération constante par
itération donne O(n).

]]> O(n²)

]]> Erreur : pas de double boucle.

]]> Complexité algorithmique — Q05 : Double boucle Quelle est la complexité de cette fonction ?
def doublons(liste):
    n = len(liste)
    for i in range(n):
        for j in range(n):
            if i != j and liste[i] == liste[j]:
                return True
    return False

]]> Deux boucles imbriquées donnent O(n²). Astuce :
on peut faire mieux ici en O(n) avec un seul
parcours qui note dans un dictionnaire les
valeurs déjà vues, car le test x in vues sur
les clés d'un dictionnaire est en O(1) en
moyenne.

]]> 1.0 0.0 0 true true abc O(n)

]]> Erreur : le for j in range(n) imbriqué
ajoute un facteur n.

]]> O(1)

]]> Erreur : double boucle, donc dépend de n.

]]> O(n!)

]]> Erreur : factorielle, c'est la complexité
d'algorithmes énumérant toutes les
permutations.

]]> O(n²)

]]> Bonne réponse : deux boucles imbriquées sur
n éléments donnent n × n = n² opérations
au pire.

]]> Complexité algorithmique — Q06 : Constante Quelle est la complexité de l'accès liste[i]
sur une liste Python ?

]]> Distinguer : liste[i] est en O(1) ;
cible in liste est en O(n) ; liste.append(x)
est en O(1) en moyenne ; insérer un élément en
tête de liste, en revanche, oblige à décaler
tous les autres et coûte O(n).

]]> 1.0 0.0 0 true true abc O(n²)

]]> Erreur : un accès par indice est trivial.

]]> O(log n)

]]> Erreur : aucune dichotomie nécessaire,
accès direct.

]]> O(n)

]]> Erreur : pour une list Python, l'accès par
indice est immédiat, on n'a pas besoin de
parcourir la liste.

]]> O(1)

]]> Bonne réponse : les listes Python sont des
tableaux, l'accès par indice est en temps
constant indépendamment de la taille.

]]> Complexité algorithmique — Q07 : Taille de l'entrée Pour une liste, qu'est-ce que la « taille de
l'entrée » n ?

]]> Selon le contexte, la « taille » peut être
différente : nombre de chiffres pour un entier,
nombre de pixels pour une image, nombre de lignes
pour un fichier, etc.

]]> 1.0 0.0 0 true true abc Le numéro de ligne où la liste est définie

]]> Le numéro de ligne du
code source ne joue
aucun rôle dans le coût
d'exécution. La taille
d'entrée caractérise le
volume de données traité,
ici le nombre d'éléments.

]]> La valeur du plus grand élément

]]> Erreur : la complexité ne dépend
généralement pas des valeurs, mais de
la structure.

]]> La quantité de mémoire qu'elle occupe en octets

]]> C'est lié, mais pas la définition standard.

]]> Le nombre d'éléments de la liste (sa longueur)

]]> Bonne réponse : la taille pertinente pour
la complexité d'une liste est sa longueur.

]]> Complexité algorithmique — Q08 : Pire / moyen / meilleur cas Pourquoi distingue-t-on pire cas, cas moyen, meilleur cas dans l'analyse de complexité ?

]]> En général, on retient le pire cas comme
référence : il garantit qu'au-delà, le coût ne
dépassera pas. Le cas moyen est utile pour
l'analyse fine en pratique.

]]> 1.0 0.0 0 true true abc Pour pouvoir annoncer la complexité la plus avantageuse

]]> Erreur : on ne choisit pas le cas qui
arrange. En pratique, on retient le
pire cas, car il fournit une
garantie valable pour toutes les
entrées possibles.

]]> Parce que les langages de programmation diffèrent

]]> Sans rapport : la complexité est
intrinsèque à l'algorithme.

]]> Parce que la complexité peut dépendre du contenu, pas seulement de la taille

]]> Bonne réponse : pour le tri par insertion,
une liste déjà triée donne O(n), une liste
renversée donne O(n²). Le pire cas est le
plus important pour les garanties.

]]> Parce que le résultat renvoyé change selon les données

]]> Erreur : confusion entre coût et
correction. Un algorithme correct
renvoie le bon résultat dans tous
les cas ; ce qui varie d'un cas à
l'autre, c'est le nombre
d'opérations effectuées, pas le
résultat.

]]> Complexité algorithmique — Q09 : Échelle de croissance Pour n = 1000, qui est le plus grand ?

]]> Échelle pour n = 1000 : log n = 10, n = 10³,
n² = 10⁶, 2ⁿ ≈ 10³⁰¹. Différence colossale.

]]> 1.0 0.0 0 true true abc n

]]> Erreur : n = 1000 = 10³, valeur
intermédiaire parmi les quatre.

]]> 2ⁿ

]]> Bonne réponse : 2¹⁰⁰⁰ ≈ 10³⁰¹, un nombre de
plus de 300 chiffres, astronomiquement plus
grand que 10⁶ ou 10³. C'est pourquoi on
évite à tout prix les algorithmes
exponentiels sur de grandes entrées.

]]> n²

]]> Erreur : n² = 10⁶, c'est grand mais très
loin derrière l'exponentielle.

]]> log₂(n)

]]> Erreur : log₂(1000) ≈ 10, c'est la valeur
la plus petite des quatre.

]]> Complexité algorithmique — Q10 : Recherche Quelle est la complexité de la recherche dichotomique dans une liste triée ?

]]> Hiérarchie classique : O(log n) (dichotomie)
<< O(n) (parcours simple) << O(n²) (double
parcours) << O(2ⁿ) (énumération exponentielle).

]]> 1.0 0.0 0 true true abc O(n)

]]> Erreur : c'est la recherche linéaire,
pas dichotomique.

]]> O(log n)

]]> Bonne réponse : à chaque étape, on divise
la liste en deux. C'est la complexité de
référence pour les algorithmes de
dichotomie.

]]> O(n²)

]]> Erreur : aucun double parcours.

]]> O(1)

]]> Erreur : on doit comparer plusieurs
éléments dans le pire cas.

]]> Complexité algorithmique — Q11 : Boucles imbriquées Quelle est la complexité de :
for i in range(n):
    for j in range(n):
        for k in range(n):
            print(i, j, k)

]]> Règle simple : pour des boucles imbriquées
sur n, la complexité est n^(profondeur).

]]> 1.0 0.0 0 true true abc O(n)

]]> Erreur : trois boucles imbriquées.

]]> O(n²)

]]> Erreur : c'est deux boucles imbriquées,
pas trois.

]]> O(3n)

]]> Erreur : ce serait trois boucles non imbriquées, soit O(n).

]]> O(n³)

]]> Bonne réponse : trois boucles imbriquées
sur n donnent n × n × n = n³ opérations.

]]> Complexité algorithmique — Q12 : Deux boucles séparées Quelle est la complexité de :
for i in range(n):
    print(i)
for j in range(n):
    print(j)

]]> Règle : O(f) + O(g) = O(max(f, g)). La
complexité d'une séquence est dominée par sa
partie la plus coûteuse.

]]> 1.0 0.0 0 true true abc O(2)

]]> Erreur : le coût dépend de n.

]]> O(n²)

]]> Erreur : les boucles ne sont pas imbriquées, on les additionne, on ne les
multiplie pas.

]]> O(n)

]]> Bonne réponse : n + n = 2n opérations, et 2n
est un O(n), les constantes sont absorbées.
On n'écrit jamais O(2n), seulement O(n).

]]> O(n log n)

]]> Erreur : aucune division du problème ni tri
ici, seulement deux parcours successifs de n
tours. Le total vaut 2n, c'est un O(n).

]]> Complexité algorithmique — Q13 : Termes dominants Quelle est la complexité de l'expression
T(n) = 3n² + 100n + 50 ?

]]> Règle systématique : ne garder que le terme
le plus puissant et supprimer la constante
multiplicative. C'est l'essence de la notation
asymptotique.

]]> 1.0 0.0 0 true true abc O(3n²)

]]> Erreur : on n'écrit pas la constante
multiplicative dans la notation O.

]]> O(n²)

]]> Bonne réponse : le terme dominant pour
n grand est 3n². Les autres termes (100n,
50) deviennent négligeables.

]]> O(50)

]]> Erreur : 50 est une constante mais elle est
dominée par les termes en n.

]]> O(100n)

]]> Erreur : on n'écrit pas la constante. De
plus, c'est dominé par n².

]]> Complexité algorithmique — Q14 : Doublement de la taille Un algorithme en O(n²) traite n = 1000
éléments en 1 seconde. Combien de temps lui
faudra-t-il pour n = 2000 ?

]]> Compétence essentielle : extrapoler le temps
d'exécution. Cela permet d'anticiper si un
algorithme va supporter la charge.

]]> 1.0 0.0 0 true true abc 1 seconde (le temps ne change pas)

]]> Erreur : ce serait O(1).

]]> 4 secondes (n doublé → temps quadruplé)

]]> Bonne réponse : O(n²) signifie temps ∝ n².
Multiplier n par 2 multiplie le temps par 4
(= 2²). Doubler n multiplierait par 4, tripler par 9.

]]> 1000 secondes

]]> Surestimation grossière.

]]> 2 secondes (n doublé → temps doublé)

]]> Erreur : ce serait O(n).

]]> Complexité algorithmique — Q15 : Pire vs meilleur cas La recherche linéaire est en O(n) au pire et
O(1) au meilleur. Que dire si l'on parle de
« complexité » sans précision ?

]]> Le pire cas a une signification claire et
garantit la performance « au pire ». Le cas
moyen demanderait de modéliser la
distribution de probabilité des entrées.

]]> 1.0 0.0 0 true true abc On parle du cas moyen

]]> Pas la convention standard, sauf
précision.

]]> On parle implicitement du meilleur cas

]]> Erreur : par convention, on prend le pire
cas si rien n'est précisé.

]]> On parle du cas le plus probable

]]> Pas une notion bien définie sans modèle
probabiliste.

]]> On parle implicitement du pire cas

]]> Bonne réponse : c'est la convention en NSI
et plus largement. Le pire cas garantit
une borne supérieure.

]]> Complexité algorithmique — Q16 : Créer une grille n × n On crée une grille de $n$ lignes et $n$ colonnes remplie de zéros :

grille = [[0 for j in range(n)] for i in range(n)]

Quel est le coût de cette instruction en fonction de $n$ ?

]]> Une compréhension cache une boucle. Deux compréhensions imbriquées se
comptent comme deux boucles imbriquées : $n \times n$ opérations, soit
un coût quadratique. Pour $n = 1\,000$, cela fait déjà un million de
cases.

]]> 1.0 0.0 0 true true abc $O(n)$

]]> Erreur : l'instruction tient sur une ligne, mais elle contient deux
boucles imbriquées. Chacune des $n$ lignes demande elle-même $n$
opérations.

]]> $O(1)$

]]> Erreur : une seule instruction ne signifie pas un coût constant.
Créer $n^2$ cases demande un travail qui grandit avec $n$.

]]> $O(n^2)$

]]> Bonne réponse : la compréhension externe fait $n$ tours et chacun
construit une ligne de $n$ zéros par la compréhension interne.
Cela fait $n \times n = n^2$ cases à remplir.

]]> $O(2n)$

]]> Erreur : les deux compréhensions ne se suivent pas, elles sont
imbriquées : on multiplie leurs nombres de tours au lieu de les
additionner, ce qui donne $n^2$.

]]> Complexité algorithmique — Q17 : Fusionner deux tables Pour fusionner une table d'élèves et une table de notes, chacune de
$n$ lignes, on écrit :

def fusion(eleves, notes):
    resultat = []
    for e in eleves:
        for x in notes:
            if e["nom"] == x["nom"]:
                resultat.append({"nom": e["nom"], "classe": e["classe"], "note": x["note"]})
    return resultat

Quel est le coût de fusion en fonction de $n$ ?

]]> Fusionner deux tables par deux boucles imbriquées coûte $n^2$
comparaisons. Sur de grandes tables, ce coût devient vite
prohibitif ; trier la table des notes par nom permettrait de
chercher chaque élève par dichotomie.

]]> 1.0 0.0 0 true true abc $O(2n)$

]]> Erreur : les deux tables ne sont pas parcourues l'une après
l'autre, mais l'une dans l'autre. Les nombres de tours se
multiplient, d'où $n^2$.

]]> $O(n^2)$

]]> Bonne réponse : pour chacune des $n$ lignes d'élèves, la boucle
interne parcourt les $n$ lignes de notes. Le test d'égalité des
noms est donc évalué $n \times n$ fois : $90\,000$ fois pour deux
tables de $300$ lignes.

]]> $O(\log n)$

]]> Erreur : aucune moitié de table n'est éliminée ici, les boucles
examinent toutes les lignes. Un coût logarithmique supposerait une
recherche dichotomique dans une table triée.

]]> $O(n)$

]]> Erreur : même si chaque élève n'a qu'une note, la boucle interne
ne s'arrête pas quand elle la trouve. Elle parcourt toute la table
des notes, pour chaque élève.

]]> Complexité algorithmique — Q18 : Algorithmes exponentiels Pourquoi évite-t-on les algorithmes en O(2ⁿ) ?

]]> Un algorithme exponentiel sur n = 100 prendrait
des milliards d'années même sur le meilleur
ordinateur du monde. Pour ces problèmes, on
utilise des heuristiques ou des algorithmes
approchés.

]]> 1.0 0.0 0 true true abc Parce qu'ils occupent trop de place sur le disque dur de la machine

]]> L'espace de stockage n'est pas en cause :
c'est le temps de calcul qui devient
prohibitif.

]]> Parce qu'aucun problème concret ne conduit à un tel algorithme

]]> Erreur : ils existent bel et bien, par
exemple pour énumérer tous les sous-ensembles
d'un ensemble de n éléments.

]]> Parce que leur coût explose dès que n atteint quelques dizaines

]]> Bonne réponse : pour n = 50, 2ⁿ ≈ 10¹⁵
opérations, hors d'atteinte même sur un
super-calculateur. La croissance
exponentielle rend l'algorithme impraticable
dès que n dépasse quelques dizaines.

]]> Parce qu'ils résultent presque toujours d'une programmation maladroite

]]> Erreur : un algorithme exponentiel peut être
parfaitement écrit, c'est sa structure
qui pose problème.

]]> Complexité algorithmique — Q19 : Estimer un temps Un algorithme effectue 10⁹ opérations
élémentaires. Sur un PC moderne (environ 10⁹
opérations / seconde), combien de temps
attendra-t-on ?

]]> Repère mental : 10⁸ par seconde en Python (un
peu lent), 10⁹ ou plus en C/C++. Permet
d'anticiper si un algorithme passera ou non
la contrainte de temps.

]]> 1.0 0.0 0 true true abc Environ une seconde

]]> Bonne réponse : 10⁹ opérations à
environ 10⁹ opérations par seconde donnent
environ une seconde (et plutôt
quelques secondes en Python, qui
tourne autour de 10⁸ par seconde).

]]> Plusieurs années

]]> Erreur : à 10⁹ opérations par seconde, une
année représente environ 3 × 10¹⁶
opérations. Plusieurs années correspondent
donc à environ 10¹⁷ opérations, très loin de 10⁹.

]]> Plusieurs jours

]]> Erreur : une journée représente environ
10¹⁴ opérations à cette vitesse. Pour 10⁹
opérations, le calcul donne 10⁹ / 10⁹ = 1
seconde.

]]> Quelques nanosecondes

]]> Erreur : 10⁹ opérations à 10⁹/s = 1
seconde, pas une nanoseconde.

]]> Complexité algorithmique — Q20 : Petit vs grand n Pour n petit (n = 10), un algorithme O(n²) est-il
forcément moins efficace qu'un algorithme O(n) ?

]]> À retenir : la notation O décrit l'évolution du coût pour de
grandes tailles. Pour les petits n, des constantes plus petites
peuvent compenser un ordre de grandeur plus grand ; pour les
grands n, l'ordre de grandeur l'emporte.

]]> 1.0 0.0 0 true true abc Aucun rapport entre ces deux complexités

]]> Erreur : ces deux coûts se comparent bien ; pour de grandes
entrées, O(n) finit toujours par battre O(n²).

]]> Oui, O(n²) est toujours moins efficace

]]> Erreur : la notation O cache des
constantes qui peuvent renverser le
classement sur les petites entrées.

]]> Non : sur les petites entrées, les constantes peuvent dominer

]]> Bonne réponse : un algorithme qui fait exactement 100 × n
opérations est en O(n), un autre qui en fait n² est en O(n²).
Pour n = 10, le premier fait 1 000 opérations et le second
seulement 100.

]]> Non, car pour n = 10 les deux donnent le même nombre d'opérations

]]> Erreur de calcul : pour n = 10, n² vaut 100 alors que n vaut 10.
Les deux nombres d'opérations ne coïncident pas ; la vraie raison
est que la notation O cache des constantes multiplicatives qui
peuvent renverser le classement.

]]> Complexité algorithmique — Q21 : Analyse fine Quelle est la complexité de :
def f(n):
    for i in range(n):
        for j in range(i):
            print(i, j)

]]> Astuce : même si la boucle interne ne va pas
jusqu'à n, la somme reste en n². Cas typique
des tris en O(n²).

]]> 1.0 0.0 0 true true abc O(n²)

]]> Bonne réponse : la boucle interne fait i
itérations. Total = 0 + 1 + ... + (n-1)
= n(n-1)/2 ≈ n²/2. C'est O(n²).

]]> O(n log n)

]]> Erreur : aucun mécanisme dichotomique.

]]> O(n)

]]> Erreur : double boucle.

]]> O(n³)

]]> Erreur : trois boucles imbriquées
donneraient n³.

]]> Complexité algorithmique — Q22 : Boucle qui divise Une boucle parcourt une variable n en la
divisant par 2 à chaque tour, jusqu'à
atteindre 1 (à chaque tour, travail
constant). Quel est le coût total ?

]]> Schéma caractéristique : à chaque itération,
la quantité de travail restant est divisée
par 2. Donne un coût logarithmique. C'est
l'analyse de la recherche dichotomique.

]]> 1.0 0.0 0 true true abc Quadratique

]]> Erreur : aucun double parcours.

]]> Constant

]]> Erreur : il y a plusieurs tours.

]]> Logarithmique

]]> Bonne réponse : on passe de n à n/2 à n/4
à ... à 1, soit log₂(n) étapes. C'est
exactement le coût de la dichotomie.

]]> Linéaire

]]> Erreur : on divise par 2, pas par
soustraction de 1.

]]> Complexité algorithmique — Q23 : Doublons dans une liste triée Pour savoir si une liste triée contient un doublon, on compare
chaque élément à son voisin :
def a_doublon(t):
    for i in range(len(t) - 1):
        if t[i] == t[i + 1]:
            return True
    return False

Pour une liste triée d'un million d'éléments sans doublon, combien de
fois le test t[i] == t[i + 1] est-il évalué, et quel est le coût ?

]]> Trier une table facilite la recherche de doublons : ils deviennent
voisins et un parcours linéaire suffit. Sans tri, il faudrait
comparer tous les couples, soit environ $n^2 / 2$ comparaisons.

]]> 1.0 0.0 0 true true abc Environ $500\,000\,000\,000$ fois, coût quadratique

]]> Erreur : ce serait le nombre de tests d'une double boucle
comparant tous les couples d'éléments, nécessaire pour une liste
non triée. Ici il n'y a qu'une boucle, car dans une liste triée
les doublons sont voisins.

]]> $1\,000\,000$ fois, coût linéaire

]]> Erreur : la boucle s'arrête à l'indice len(t) - 2, car le
dernier élément n'a pas de voisin à droite. On fait donc
$999\,999$ tests, pas $1\,000\,000$ ; le coût est bien linéaire.

]]> Environ $19$ fois, coût logarithmique

]]> Erreur : le fait que la liste soit triée n'entraîne pas une
dichotomie. Cette fonction examine les voisins un par un, sans
jamais éliminer de moitié, et fait $999\,999$ tests.

]]> $999\,999$ fois, coût linéaire

]]> Bonne réponse : i prend les valeurs de $0$ à $999\,998$, soit
$999\,999$ tests, et aucun ne renvoie True. Comme la liste est
triée, deux valeurs égales sont forcément voisines : un seul
parcours suffit, d'où un coût linéaire.

]]> Complexité algorithmique — Q25 : Synthèse Parmi les affirmations suivantes sur la
complexité, laquelle est fausse ?

]]> Maxime : « la notation O est un guide, pas une vérité absolue ».
Il faut toujours tester en pratique pour les cas réels, surtout sur
de petites entrées.

]]> 1.0 0.0 0 true true abc Le tri par sélection a un coût quadratique dans le pire cas

]]> Vrai : il fait environ n²/2 comparaisons, quel que soit l'ordre
initial.

]]> Un algorithme O(n) est toujours plus rapide qu'un algorithme O(n²)

]]> Faux (donc bonne réponse) : O(n) est plus rapide pour de grandes
entrées, mais sur de petites entrées un O(n²) avec une petite
constante peut battre un O(n) avec une grosse constante. Exemple :
avec n² opérations contre 100 × n, n² est plus petit tant que
n < 100.

]]> Pour les boucles imbriquées, on multiplie les complexités ; pour les séquences, on prend le maximum

]]> Vrai : règle de calcul standard.

]]> La complexité O ignore les constantes multiplicatives

]]> Vrai : O(2n) = O(n) = O(100n).

]]> Complexité algorithmique — Q26 : Boucle while soustractive Quelle est la complexité de la fonction
suivante en fonction de n ?
def f(n):
    while n > 0:
        print(n)
        n = n - 3

]]> À retenir : soustraire une constante à n à
chaque itération donne un coût linéaire ;
diviser n par une constante donne un coût
logarithmique. Cette distinction est la clé
pour reconnaître les algorithmes
logarithmiques.

]]> 1.0 0.0 0 true true abc O(log n)

]]> Erreur : la division par deux donne du
logarithmique. Ici on soustrait une
constante à chaque tour, donc le nombre
d'itérations est proportionnel à n, pas à
log n.

]]> O(1)

]]> Erreur : le nombre d'itérations dépend
clairement de n. Pour n = 30, la boucle
tourne dix fois ; pour n = 300, elle
tourne cent fois. Ce n'est pas constant.

]]> O(n)

]]> Bonne réponse : n décroît par pas de 3.
Le nombre d'itérations vaut environ n / 3,
ce qui est O(n) car on absorbe la constante
multiplicative. Toute boucle while qui
soustrait une constante à n est en O(n).

]]> O(n²)

]]> Erreur : il n'y a pas de double boucle. Le
coût est dominé par le nombre d'itérations
de l'unique while.

]]> Complexité algorithmique — Q27 : Taille vs valeur de l'entrée On considère la fonction qui compte les
chiffres d'un entier positif :
def chiffres(n):
    c = 0
    while n > 0:
        n = n // 10
        c += 1
    return c

Quelle est sa complexité ?

]]> Subtilité importante : la « taille » d'un
entier n est son nombre de chiffres,
donc de l'ordre de log(n). Les algorithmes
classiques sur les entiers sont dits
« linéaires » quand leur coût est
proportionnel au nombre de chiffres, c'est-à-
dire O(log n) en fonction de la valeur.

]]> 1.0 0.0 0 true true abc O(n) en fonction de la valeur de n

]]> Erreur : à chaque
itération, n est divisé par 10. Donc le
nombre d'itérations est de l'ordre de
log₁₀(n), pas de n. Pour n = 10⁶, la
boucle ne tourne que sept fois, pas un
million.

]]> O(1) quelle que soit la valeur de n

]]> Erreur : la boucle dépend de la valeur de
n. Plus n est grand, plus elle tourne
longtemps.

]]> O(log n) en fonction de la valeur de n

]]> Bonne réponse : on divise n par 10 à
chaque itération, donc log₁₀(n) étapes.
C'est aussi exactement le nombre de chiffres de n dans son écriture
décimale. Une autre façon de le dire : la
complexité est linéaire par rapport à
la taille (nombre de chiffres) de n.

]]> O(n²) en fonction de la valeur de n

]]> Erreur : aucune double boucle ni structure
quadratique. Le coût ne grandit pas comme
n².

]]> Complexité algorithmique — Q28 : Coût des opérations sur les listes Parmi ces opérations sur une liste Python de
taille n, laquelle est la plus coûteuse
au pire ?

]]> Repères à connaître pour les listes Python : accès par indice,
len et append en O(1) ; x in liste, max, min et sum en
O(n), car ils parcourent toute la liste au pire. Ces ordres de
grandeur guident l'écriture d'un algorithme efficace.

]]> 1.0 0.0 0 true true abc liste[0] (lecture du premier élément)

]]> Erreur : l'accès par indice est en O(1) sur une liste Python, qui
est un tableau. Pas besoin de parcourir.

]]> x in liste (test de présence)

]]> Bonne réponse : le test de présence est une
recherche linéaire cachée. Python compare
x à chaque élément jusqu'à le trouver ; si
la valeur est absente, il parcourt les n
éléments, d'où un coût en O(n) au pire. Un
in répété sur une liste d'un million
d'éléments devient très lent.

]]> liste.append(x) (ajout en fin)

]]> Erreur : append ajoute l'élément en fin de liste en temps
constant, sans parcourir les éléments déjà présents.

]]> len(liste) (longueur de la liste)

]]> Erreur : len est en O(1). Python connaît la longueur de la liste
sans avoir à compter ses éléments.

]]> Complexité algorithmique — Q29 : Choisir selon la taille Sur un PC moderne, on dispose d'une seconde
pour exécuter un algorithme (environ 10⁸ opérations
Python). Quelle est la plus grande taille
d'entrée que l'on peut traiter avec un
algorithme en O(n²) ?

]]> Repères de seuils pratiques (1 seconde de calcul, environ 10⁸
opérations) : O(2ⁿ) → n ≈ 25 ; O(n³) → n ≈ 500 ; O(n²) → n ≈ 10⁴ ;
O(n) → n ≈ 10⁸ ; O(log n) → n gigantesque. Indispensable pour
évaluer la faisabilité d'un algorithme avant de l'écrire.

]]> 1.0 0.0 0 true true abc Environ 30 (trentaine)

]]> Erreur : ce serait pour un algorithme exponentiel O(2ⁿ). Avec
n = 30, on atteint déjà environ 10⁹ opérations, au-delà du
budget. Pour un algorithme quadratique, on peut traiter beaucoup
plus.

]]> Environ 10⁸ (cent millions)

]]> Erreur : ce serait pour un algorithme en
O(n) (linéaire). Pour un algorithme
quadratique, il faut prendre la racine
carrée du budget d'opérations.

]]> Environ 10⁴ (dix mille)

]]> Bonne réponse : on cherche n tel que n² ≤ 10⁸, donc
n ≤ √(10⁸) = 10⁴. À retenir : un algorithme quadratique devient
lent dès quelques dizaines de milliers d'éléments.

]]> Environ 10⁶ (un million)

]]> Erreur : pour n = 10⁶, un algorithme
quadratique fait 10¹² opérations, ce qui
prendrait environ trois heures. Hors
budget.

]]> Complexité algorithmique — Q30 : Une boucle intérieure qui grandit Combien de fois l'instruction compteur = compteur + 1 est-elle
exécutée, en fonction de n ?
compteur = 0
for i in range(n):
    for j in range(i):
        compteur = compteur + 1

]]> Que la boucle intérieure fasse $n$ ou $i$ tours, le coût total reste
en $O(n^2)$ : le facteur $1/2$ ne change pas la classe.

]]> 1.0 0.0 0 true true abc $n(n-1)/2$ fois, soit un coût quadratique

]]> Bonne réponse : la boucle intérieure fait $0$, puis $1$, puis
$2$ tours, jusqu'à $n - 1$. La somme vaut $n(n-1)/2$, de
l'ordre de $n^2 / 2$.

]]> $n$ fois, soit un coût linéaire

]]> Erreur : la boucle intérieure multiplie le travail ; seule la
boucle extérieure fait $n$ tours.

]]> $n^2$ fois exactement, soit un coût quadratique

]]> Erreur : $n^2$ serait le compte avec range(n) à l'intérieur ;
range(i) en fait environ la moitié. L'ordre de grandeur reste
quadratique.

]]> $2n$ fois, soit un coût linéaire

]]> Erreur : deux boucles imbriquées se multiplient, elles ne
s'additionnent pas.

]]> Complexité algorithmique — Q31 : Une boucle intérieure de taille fixe Quelle est la classe de complexité de ce programme en fonction de
n ?
for i in range(n):
    for j in range(10):
        total = total + t[i] * j

]]> Pour classer un programme, on ne garde que ce qui dépend de la
taille de l'entrée : les boucles de taille fixe comptent pour une
constante.

]]> 1.0 0.0 0 true true abc $O(n)$, la boucle intérieure étant de taille fixe

]]> Bonne réponse : $10n$ opérations, et une constante ne change
pas la classe. Le coût grandit comme $n$.

]]> $O(n^2)$, deux boucles étant imbriquées l'une dans l'autre

]]> Erreur : l'imbrication ne suffit pas ; il faut que les deux
boucles dépendent de $n$. Ici la seconde fait toujours dix tours.

]]> $O(10n)$, une classe à part entre linéaire et quadratique

]]> Erreur : les constantes multiplicatives disparaissent dans la
notation $O$ ; $O(10n)$ se note $O(n)$.

]]> $O(1)$, le nombre dix étant fixé une fois pour toutes

]]> Erreur : la boucle extérieure dépend de $n$, le coût n'est pas
constant.

]]> Complexité algorithmique — Q32 : Une recherche dans une boucle La fonction appartient(x, t) fait une recherche linéaire dans la
liste t, de taille n. Quelle est la classe de complexité de ce
programme ?
for i in range(n):
    if appartient(t[i], u):
        nb = nb + 1

La liste u est elle aussi de taille n.

]]> Le coût d'un appel de fonction n'est pas constant : il faut le
multiplier par le nombre d'appels.

]]> 1.0 0.0 0 true true abc $O(n^2)$, chaque tour appelant une fonction de coût linéaire

]]> Bonne réponse : $n$ tours, et chacun parcourt jusqu'à $n$
éléments de u. Le coût total est de l'ordre de $n \times n$.

]]> $O(n)$, le programme ne contenant qu'une boucle

]]> Erreur : la boucle cachée dans appartient compte aussi.

]]> $O(1)$, un appel de fonction étant une opération élémentaire

]]> Erreur : un appel coûte ce que coûte la fonction appelée, ici un
parcours de u.

]]> $O(\log n)$, la fonction cherchant par dichotomie

]]> Erreur : la recherche est linéaire, et même dichotomique, la
boucle extérieure resterait en $n$.

]]> Complexité algorithmique — Q33 : Accéder à une valeur par sa clé Quelle est la classe de complexité de l'accès d[cle] dans un
dictionnaire Python de $n$ entrées ?

]]> Choisir un dictionnaire plutôt qu'une liste transforme une
recherche linéaire en accès constant.

]]> 1.0 0.0 0 true true abc $O(1)$, le temps ne dépendant pas de $n$

]]> Bonne réponse : un dictionnaire calcule directement où ranger
chaque clé, ce qui rend l'accès constant en moyenne, quel que
soit $n$.

]]> $O(n)$, toutes les clés devant être comparées

]]> Erreur : c'est le coût d'une recherche dans une liste, pas dans
un dictionnaire.

]]> $O(\log n)$, les clés étant triées en interne

]]> Erreur : les clés d'un dictionnaire ne sont pas triées, et
l'accès est encore plus rapide qu'une dichotomie.

]]> $O(n^2)$, chaque clé étant comparée à toutes les autres

]]> Erreur : aucune double boucle n'intervient dans un accès par
clé.

]]> Complexité algorithmique — Q34 : Estimer le temps d'un algorithme quadratique Un algorithme en $O(n^2)$ traite $1\,000$ éléments en $1$ s.
Combien de temps lui faut-il pour $10\,000$ éléments ?

]]> Connaître la classe d'un algorithme permet d'extrapoler : en
$O(n^2)$, multiplier la taille par $k$ multiplie le temps par
$k^2$.

]]> 1.0 0.0 0 true true abc Environ $100$ s

]]> Bonne réponse : la taille est multipliée par dix, donc le temps
par dix au carré, soit $100$.

]]> Environ $10$ s

]]> Erreur : un temps multiplié par dix correspondrait à un
algorithme linéaire.

]]> Toujours $1$ s

]]> Erreur : un coût quadratique dépend fortement de la taille.

]]> Environ $100 \times 100$ s

]]> Erreur : le facteur est le carré du rapport des tailles, pas
son carré au carré.

]]> Complexité algorithmique — Q35 : Deux tris sur un million d'éléments Pour $n = 10^6$, on compare un tri en $O(n \log_2 n)$ et un tri en
$O(n^2)$, avec la même constante. Quel est l'ordre de grandeur du
rapport de leurs coûts ?

]]> Sur un million d'éléments, un tri quadratique est des dizaines de
milliers de fois plus lent qu'un tri en $n \log n$ : la classe de
complexité décide de ce qui est faisable.

]]> 1.0 0.0 0 true true abc Environ $50\,000$, soit $n / \log_2 n$

]]> Bonne réponse : $n^2 = 10^{12}$ et $n \log_2 n \approx 2 \times
10^7$. Le rapport vaut $10^{12} / (2 \times 10^7) = 5 \times
10^4$.

]]> Environ $2$, les deux étant presque linéaires

]]> Erreur : $n^2$ n'a rien de linéaire ; l'écart est énorme pour
$n$ grand.

]]> Environ $10^6$, soit $n$, le rapport des tailles

]]> Erreur : le rapport est $n / \log_2 n$, pas $n$, car le tri en
$n \log_2 n$ ne coûte pas $n$.

]]> Environ $20$, soit $\log_2 n$, le facteur du tri efficace

]]> Erreur : $20$ est le rapport entre $n \log_2 n$ et $n$, pas
entre $n^2$ et $n \log_2 n$.

]]> Complexité algorithmique — Q36 : Compter plutôt que chronométrer Pourquoi évalue-t-on le coût d'un algorithme en comptant des
opérations plutôt qu'en mesurant un temps d'exécution ?

]]> La complexité est une propriété de l'algorithme, pas de
l'ordinateur qui l'exécute.

]]> 1.0 0.0 0 true true abc Parce que le compte ne dépend ni de la machine ni du langage

]]> Bonne réponse : un chronomètre mesure un programme sur une
machine donnée ; le nombre d'opérations décrit l'algorithme
lui-même et permet de comparer des méthodes.

]]> Parce que les temps d'exécution sont impossibles à mesurer

]]> Erreur : on mesure très bien un temps, mais il ne caractérise
pas l'algorithme.

]]> Parce que les opérations sont toutes de même durée

]]> Erreur : elles ne durent pas exactement le même temps ; on les
suppose bornées, ce qui suffit pour un ordre de grandeur.

]]> Parce que le nombre d'opérations est toujours plus petit que le temps

]]> Erreur : les deux grandeurs ne se comparent pas.

]]> Complexité algorithmique — Q37 : Ce qu'est une opération élémentaire Dans le décompte du coût d'un algorithme, que considère-t-on comme
une opération élémentaire ?

]]> Compter les opérations élémentaires demande de voir ce que cache
chaque instruction : une boucle, un appel ou un test d'appartenance
peuvent valoir $n$ opérations.

]]> 1.0 0.0 0 true true abc Une affectation, une comparaison ou un calcul, de durée bornée

]]> Bonne réponse : ces opérations prennent un temps qui ne dépend
pas de la taille des données. Les compter donne l'ordre de
grandeur du coût.

]]> Un tour de boucle complet, quel que soit son contenu

]]> Erreur : un tour de boucle peut contenir d'autres boucles ou
des appels coûteux.

]]> Un appel de fonction, quel que soit le coût de la fonction appelée

]]> Erreur : un appel coûte ce que coûte la fonction, qui peut
parcourir toute une liste.

]]> Une ligne de code Python, quelle que soit l'instruction qu'elle contient

]]> Erreur : une seule ligne peut cacher un parcours entier, comme
x in liste.

]]>