$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) ?
`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
`

]]> 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 :
`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)

]]> 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².
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 des éléments d'une liste

]]> Erreur : un seul parcours, O(n).

]]> La recherche linéaire d'un élément dans une liste

]]> Erreur : un seul parcours, O(n).

]]> La recherche dichotomique dans une liste triée

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

]]> Les tris efficaces, comme le tri fusion

]]> Bonne réponse : les tris « diviser pour
régner » (tri fusion, tri rapide) et le
Timsort de Python atteignent O(n log n),
complexité 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 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 (~ 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 à
~ 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 à ~ 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 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 ces deux complexités

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

]]> 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.

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

]]> Erreur de calcul : pour n = 10,
n² = 100 alors que
n log₂ n ≈ 33. Les deux ordres
de grandeur 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 :
`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 — 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 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 et len en O(1) ; append
en O(1) amorti ; x in liste, max, min et
sum en O(n), car ils parcourent toute la
liste au pire. 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.

]]> 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 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.

]]>