$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

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

]]> La quantité de ressources (temps ou mémoire) consommée par un algorithme en fonction de la taille de l'entrée

]]> Bonne réponse : on étudie comment le coût
évolue lorsque la taille n grandit.

]]> La beauté du code

]]> Subjectif, sans rapport.

]]> La difficulté de comprendre le code

]]> 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 (à une constante près)

]]> 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 n octets de mémoire

]]> 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) ?
`python
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 ?
`python
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
`

]]> Double boucle = O(n²). Astuce : on peut faire
mieux ici en O(n) avec un set (test
d'appartenance en O(1)).

]]> 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] = O(1) ; cible in liste
= O(n) ; liste.append(x) = O(1) en moyenne ;
liste.insert(0, x) = 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 faire les énoncés plus longs

]]> La distinction des trois
cas a une véritable raison
mathématique : la complexité
d'un algorithme peut varier
fortement selon les données
en entrée, et il faut donc
préciser quel scénario on
analyse.

]]> 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 de l'entrée, pas seulement de sa 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 l'ordinateur a parfois la flemme

]]> Un ordinateur exécute
systématiquement les
instructions qui lui
sont fournies. La variation
de coût provient de
l'algorithme et des données,
pas du matériel.

]]> 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 = 1000

]]> Erreur : intermédiaire.

]]> 2ⁿ ≈ 10³⁰¹ (un nombre de plus de 300 chiffres)

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

]]> n² = 1 000 000

]]> Erreur : c'est grand mais pas le plus grand.

]]> log₂(n) ≈ 10

]]> Erreur : 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 :
`python
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 :
`python
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) (et non O(2n), car les constantes sont absorbées)

]]> Bonne réponse : 2n est un O(n). On n'écrit
jamais O(2n), seulement O(n).

]]> O(n × m) où m = n

]]> Erreur : c'est O(n + n) = O(2n) = 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².
Doubler n multiplie le temps par 4
(= 2²). Tripler n multiplierait par 9
(= 3²).

]]> 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 : Complexité spatiale Quelle est la complexité spatiale (mémoire
additionnelle) du tri par insertion ?

]]> Distinction temps / espace : le tri par
insertion est lent (O(n²) en temps) mais
économe en mémoire (O(1) en espace). Le tri
fusion est rapide (O(n log n)) mais coûteux
en mémoire (O(n)).

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

]]> Bonne réponse : tri en place, ne nécessite
que quelques variables temporaires
indépendamment de n.

]]> O(n²)

]]> Erreur : on n'alloue pas de tableau 2D.

]]> O(log n)

]]> Erreur : pas de mécanisme dichotomique ici
(la boucle parcourt n éléments).

]]> O(n)

]]> Erreur : on ne crée pas de copie de la
liste.

]]> Complexité algorithmique — Q17 : O(n log n) Pour quel type d'algorithme la complexité
O(n log n) est-elle typique ?

]]> O(n log n) ≈ O(n) sur de petites entrées,
mais bien meilleur que O(n²) sur de grandes.
Pour n = 10⁶ : n log n ≈ 2 × 10⁷, n² = 10¹².
Différence colossale.

]]> 1.0 0.0 0 true true abc Le calcul de la somme d'une liste

]]> Erreur : O(n).

]]> La recherche linéaire

]]> Erreur : O(n).

]]> La recherche dichotomique

]]> Erreur : la recherche dichotomique est en
O(log n), pas O(n log n).

]]> Les tris efficaces (fusion, rapide, Timsort)

]]> Bonne réponse : les tris « diviser pour
régner » atteignent O(n log n), prouvée
optimale pour les tris par comparaisons.

]]> 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 prennent trop de place sur le disque

]]> La consommation mémoire n'est pas la
raison principale.

]]> Parce qu'ils n'existent pas

]]> Erreur : ils existent (par exemple,
énumérer tous les sous-ensembles).

]]> Parce que pour n modeste (n = 50), 2ⁿ ≈ 10¹⁵, ce qui est hors d'atteinte même sur un super-calculateur

]]> Bonne réponse : la croissance
exponentielle rend impraticable un
algorithme dès que n dépasse quelques
dizaines.

]]> Parce qu'ils sont mal écrits

]]> 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 (~ 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 : règle d'or, un PC
moderne effectue grosso modo 10⁸ à 10⁹
opérations Python par seconde. 10⁹ ≈
quelques secondes.

]]> Plusieurs années

]]> Erreur : valeur attendue pour ~ 10¹⁵
opérations.

]]> Plusieurs jours

]]> Erreur : on aurait dépassé largement les 10⁹
opérations.

]]> 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 O(n log n) ?

]]> Maxime : « la notation O est asymptotique ».
Pour les petits n, des constantes plus petites
peuvent compenser un ordre de grandeur plus
grand. Asymptotiquement, l'ordre l'emporte.

]]> 1.0 0.0 0 true true abc Aucun rapport entre les deux

]]> Erreur : asymptotiquement, O(n log n) bat
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 et l'algorithme « plus simple » peut être plus rapide

]]> Bonne réponse : Python utilise Timsort
(n log n) mais bascule sur le tri par
insertion (O(n²)) pour les sous-tableaux
de moins de ~ 64 éléments. Preuve par la
pratique.

]]> Cela dépend de la couleur de l'écran

]]> La complexité d'un
algorithme est une
mesure mathématique
intrinsèque, indépendante
de l'affichage. Elle ne
dépend que du nombre
d'opérations effectuées
en fonction de la taille
d'entrée.

]]> Complexité algorithmique — Q21 : Analyse fine Quelle est la complexité de :
`python
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 : Mesure empirique Pour vérifier la complexité d'un algorithme
empiriquement, on mesure son temps t pour
différentes tailles n. Si t est
proportionnel à n², comment cela apparaît-il
sur un graphique log-log (axes logarithmiques) ?

]]> Astuce expérimentale : tracer en log-log et
mesurer la pente. C'est ainsi qu'on confirme
visuellement la complexité d'un algorithme
en pratique.

]]> 1.0 0.0 0 true true abc Une parabole

]]> Erreur : c'est ce qu'on aurait sur des axes
linéaires, pas logarithmiques.

]]> Une courbe exponentielle

]]> Erreur : sur un graphe log-log, n²
apparaît linéaire.

]]> Une droite de pente 2

]]> Bonne réponse : si t = c × n², alors
log(t) = log(c) + 2 × log(n). C'est une
droite de pente 2 sur un graphe log-log.
Pour une complexité O(n^k), la pente est
exactement k.

]]> Une horizontale

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

]]> Complexité algorithmique — Q24 : Inclusion des classes Une fonction en O(n) est-elle forcément aussi
en O(n²) ?

]]> C'est pour cela qu'on dit « la complexité
est O(n²) » plutôt que « la complexité
vaut O(n²) » : c'est un majorant. La
borne serrée s'écrit Θ(n²) (« thêta »),
hors programme NSI.

]]> 1.0 0.0 0 true true abc Non, ce sont des classes différentes

]]> Erreur : O(n²) inclut O(n).

]]> Oui : O(n²) est une borne supérieure plus large, qui inclut O(n)

]]> Bonne réponse : O(f) signifie « majoré par
c × f ». Si f croît plus vite que g (au
sens asymptotique), alors O(g) ⊆ O(f).
Donc O(n) ⊆ O(n²) ⊆ O(n³)...

]]> Oui, mais seulement pour des n positifs

]]> Précision inutile : la complexité s'étudie
pour n grand.

]]> Non, sauf si n est petit

]]> Erreur : la propriété est asymptotique.

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

]]> Maxime : « la complexité asymptotique 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 La complexité spatiale mesure la mémoire additionnelle utilisée

]]> Vrai : c'est sa définition.

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

]]> Faux (donc bonne réponse) : O(n) est plus
rapide asymptotiquement, mais sur de
petites entrées un O(n²) avec une petite
constante peut battre un O(n) avec une
grosse constante. Exemple : Timsort
bascule sur du tri par insertion pour
n < 64.

]]> 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 ?
`python
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 :
`python
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 n

]]> Réponse partielle : c'est faux. À 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) car n est une simple variable

]]> 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 n (autrement dit, linéaire en fonction du nombre de chiffres)

]]> 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²)

]]> 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 et len en O(1) ; append,
pop() (en fin) en O(1) amorti ; insert(0,
x), pop(0), remove, in en O(n). Ces
ordres de grandeur déterminent le choix de la
structure de données pour un algorithme
donné.

]]> 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 en réalité un
tableau dynamique). Pas besoin de
parcourir.

]]> liste.insert(0, x) (insertion en tête)

]]> Bonne réponse : insérer en tête oblige à
décaler tous les éléments existants
d'une case vers la droite, ce qui coûte
O(n). Sur une liste de un million
d'éléments, c'est très lent. Pour un usage
intensif d'insertion en tête, utiliser un
collections.deque (O(1)).

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

]]> Erreur : append est en O(1) en moyenne. Une
réallocation occasionnelle peut prendre
plus de temps, mais le coût amorti par
opération reste constant.

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

]]> Erreur : len est en O(1). Python stocke la
longueur dans un attribut de la liste, pas
besoin de compter à chaque appel.

]]> Complexité algorithmique — Q29 : Choisir selon la taille Sur un PC moderne, on dispose d'une seconde
pour exécuter un algorithme (~ 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, ~ 10⁸ opérations) : O(2ⁿ) → n ≈ 25 ;
O(n³) → n ≈ 500 ; O(n²) → n ≈ 10⁴ ; O(n log
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 a
déjà 10⁹ opérations, soit la limite. Mais
pour 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. Comparer avec O(n
log n) qui supporte plusieurs millions.

]]> Environ 10⁶ (un million)

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

]]>