$course$/QCM de NSI/Première/Recherche linéaire Recherche séquentielle d'un élément dans une liste,
parcours élément par élément, cas favorables et
défavorables, complexité, comparaison avec la recherche
dichotomique, variantes (indice, booléen, toutes les
occurrences).

]]> Recherche linéaire — Q01 : Recherche linéaire ou séquentielle En quoi consiste la recherche linéaire (ou séquentielle) ?

]]> La recherche linéaire est universelle : elle
fonctionne sur une liste, une chaîne ou un
p-uplet, sans hypothèse sur l'ordre des
éléments. Sa simplicité a un prix : elle peut
nécessiter jusqu'à n comparaisons.

]]> 1.0 0.0 0 true true abc Sauter directement à la position centrale puis comparer

]]> Erreur : c'est l'idée de la recherche
dichotomique, qui n'est applicable qu'à
une liste triée.

]]> Parcourir la liste et comparer chaque élément à la cible

]]> Bonne réponse : c'est l'algorithme le plus
simple. Il fonctionne sur n'importe quelle
liste (triée ou non).

]]> Utiliser un dictionnaire pour aller directement à la valeur

]]> Erreur : l'accès direct par clé d'un
dictionnaire est une autre stratégie,
différente de la recherche linéaire.

]]> Trier la liste puis chercher le premier élément

]]> Erreur : la recherche linéaire ne nécessite
pas de tri préalable.

]]> Recherche linéaire — Q02 : Liste triée ou non ? La recherche linéaire suppose-t-elle que la liste
soit triée ?

]]> Quand la liste est triée, on peut faire mieux
avec la dichotomique (O(log n)). Mais la linéaire
reste un choix correct, simple et universel.

]]> 1.0 0.0 0 true true abc Uniquement si la liste contient des nombres

]]> Erreur : la recherche linéaire fonctionne
quel que soit le type des éléments
(nombres, chaînes, objets...).

]]> Non, elle fonctionne sur n'importe quelle liste

]]> Bonne réponse : c'est précisément l'avantage
de la recherche linéaire. On peut l'appliquer
à des données non triées (par exemple, une
liste de noms saisis dans l'ordre d'arrivée).

]]> Uniquement si la liste contient au moins 10 éléments

]]> Erreur : la recherche linéaire fonctionne
aussi sur des listes courtes ou vides.

]]> Oui, sinon elle ne fonctionne pas

]]> Erreur : c'est la dichotomique qui exige
une liste triée. La linéaire fonctionne sans
condition.

]]> Recherche linéaire — Q03 : Pire cas Quel est le nombre maximal de comparaisons dans
une recherche linéaire dans une liste de longueur n ?

]]> Pire cas : l'élément n'est pas présent. On a fait
n comparaisons négatives. Meilleur cas : l'élément
est en première position, une seule comparaison.

]]> 1.0 0.0 0 true true abc n²

]]> Erreur : on parcourt la liste une seule fois, sans imbrication de boucle.

]]> log(n)

]]> Erreur : c'est la complexité de la recherche
dichotomique, applicable seulement aux listes
triées.

]]> n

]]> Bonne réponse : dans le pire cas (élément
absent ou en dernière position), il faut
comparer chacun des n éléments. La complexité
est en O(n).

]]> n / 2

]]> Erreur : n / 2 est le nombre moyen de
comparaisons (en supposant l'élément présent
en position aléatoire), pas le maximum.

]]> Recherche linéaire — Q04 : Quand arrête-t-on la boucle ? Dans une recherche linéaire bien programmée, quand
arrête-t-on de parcourir la liste ?

]]> Schéma Python typique :
for i in range(len(liste)):
if liste[i] == cible: return i
return -1.

]]> 1.0 0.0 0 true true abc Au bout de log(n) comparaisons

]]> Erreur : c'est la dichotomique. Sans
hypothèse de tri, on ne peut pas s'arrêter
avant.

]]> Dès que le tout premier élément testé n'est pas le bon

]]> Erreur : si le premier élément n'est pas le
bon, l'élément peut quand même être plus loin.

]]> Toujours après avoir parcouru toute la liste

]]> Pas optimal : si on a déjà trouvé l'élément,
inutile de continuer. Mais cela donne malgré
tout un résultat correct (juste plus lent).

]]> Dès que la cible est trouvée, ou à la fin de la liste

]]> Bonne réponse : on s'arrête au plus tôt, par
exemple avec un return dès que la cible est
trouvée. Cela améliore le temps moyen mais ne
change pas le pire cas (élément absent,
parcours complet).

]]> Recherche linéaire — Q05 : Que renvoyer si absent ? Si l'élément cherché n'est pas dans la liste,
que peut-on raisonnablement renvoyer ?

]]> Quelle que soit la convention choisie, la
spécification de la fonction doit l'indiquer,
et le programme qui l'appelle doit tester ce
cas avant d'utiliser le résultat comme une
position.

]]> 1.0 0.0 0 true true abc La dernière position de la liste (n - 1)

]]> Erreur : on confondrait avec « élément en
dernière position ».

]]> La position 0 (par défaut)

]]> Erreur : on confondrait avec « élément en
première position ».

]]> La longueur de la liste

]]> Erreur : valeur arbitraire, pas une
convention reconnue.

]]> None ou -1, pour signaler l'absence

]]> Bonne réponse : ce sont les deux conventions
courantes. Au programmeur de choisir, mais
il faut être cohérent dans tout le code.

]]> Recherche linéaire — Q06 : Code Python typique Quel code implémente correctement la recherche
linéaire et renvoie l'indice de la cible (ou
-1 si absente) ?

]]> Vérifier deux choses dans toute fonction de
recherche : le type de retour (indice,
booléen, ou objet), et le comportement en
cas d'absence.

]]> 1.0 0.0 0 true true abc

def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            return i
        return -1

]]> Erreur d'indentation : return -1 est
dans la boucle, ce qui termine après la
première comparaison. La fonction renverrait
toujours 0 ou -1 selon le premier élément.

]]>

def chercher(liste, cible):
    for x in liste:
        if x == cible:
            return x
    return -1

]]> Erreur : on renvoie x (la valeur), pas
son indice. La spécification demandait
l'indice.

]]>

def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            return i
    return -1

]]> Bonne réponse : parcours par indice, retour
précoce dès la cible trouvée, -1 si la
boucle se termine sans trouver.

]]>

def chercher(liste, cible):
    i = 0
    while i < len(liste):
        if liste[i] == cible:
            return i
    return -1

]]> Erreur : i n'est jamais incrémenté. Si la
cible n'est pas en première position, la
condition i < len(liste) reste vraie et le
test liste[0] == cible se répète sans fin :
boucle infinie. Il manque i = i + 1 dans
la boucle.

]]> Recherche linéaire — Q07 : Opérateur `in` L'expression Python 42 in liste réalise
implicitement quelle opération ?

]]> L'opérateur in cache une boucle : son coût
est linéaire. Placer un test in dans une
boucle revient donc à imbriquer deux
parcours.

]]> 1.0 0.0 0 true true abc Un tri complet de la liste avant de répondre

]]> Erreur : in ne modifie pas la liste et ne
la trie pas.

]]> Une recherche dichotomique, rapide

]]> Erreur : Python ne suppose pas que la liste
est triée. Il fait du linéaire.

]]> Une recherche linéaire, élément par élément

]]> Bonne réponse : le parcours s'arrête à la
première correspondance. Sur une liste de
n éléments, in peut donc effectuer
jusqu'à n comparaisons.

]]> Une vérification du type des éléments

]]> Erreur : in teste l'appartenance, pas le
type.

]]> Recherche linéaire — Q08 : Liste vide Que doit renvoyer une recherche linéaire (qui
renvoie l'indice ou -1) sur une liste vide ?

]]> Cas limite à toujours tester. Bonne pratique :
écrire un test unitaire assert chercher([], x) == -1.

]]> 1.0 0.0 0 true true abc Le déclenchement immédiat d'une exception

]]> Pas nécessairement. Avec le schéma
standard, la boucle ne s'exécute pas et la
fonction renvoie -1 proprement.

]]> None

]]> Possible (autre convention), mais selon
notre énoncé, la fonction renvoie -1.

]]> -1 (élément absent)

]]> Bonne réponse : aucune valeur n'est dans la
liste vide, donc tout élément y est absent.
La boucle ne s'exécute pas, on tombe
directement sur return -1.

]]> 0

]]> Erreur : 0 signifierait « trouvé en première
position » alors qu'il n'y a aucune position.

]]> Recherche linéaire — Q09 : Recherche de minimum Trouver le minimum d'une liste est aussi un
cas de recherche linéaire. Quelle est sa
complexité ?

]]> Note importante : ici on ne peut pas s'arrêter tôt car on ne sait pas si un élément plus
petit existe plus loin. C'est différent de la
recherche d'une valeur précise.

]]> 1.0 0.0 0 true true abc O(n²) : double boucle nécessaire

]]> Erreur : un seul parcours suffit (en gardant
le minimum courant dans une variable).

]]> O(1) : on prend juste le premier élément

]]> Erreur : le premier élément n'est pas
forcément le minimum (sauf liste triée).

]]> O(log n) : recherche dichotomique

]]> Erreur : ne fonctionne pas, même sur liste
triée la dichotomique cherche une cible
précise, pas un extremum.

]]> O(n) : on doit comparer tous les éléments

]]> Bonne réponse : pour garantir le minimum, il
faut examiner chaque élément. On ne peut
pas s'arrêter avant la fin (contrairement à
la recherche d'une cible précise).

]]> Recherche linéaire — Q10 : Trace simple On cherche cible = 7 dans liste = [3, 5, 7, 2, 7].
Combien de comparaisons effectue une recherche
linéaire avec arrêt précoce ?

]]> Sans arrêt précoce, on aurait fait 5
comparaisons et compté 2 occurrence(s). Avec
arrêt précoce, 3 comparaisons et indice retourné
directement (= 2).

]]> 1.0 0.0 0 true true abc 5

]]> Erreur : on ne parcourt pas toute la liste si
on s'arrête au premier 7 rencontré.

]]> 1

]]> Erreur : il faut comparer 3, 5 avant
d'arriver à 7.

]]> 2

]]> Erreur : il faut bien tester liste[2] (et
la trouver égale à 7) pour conclure.

]]> 3

]]> Bonne réponse : liste[0]=3 (≠), liste[1]=5 (≠), liste[2]=7 (=) → on s'arrête. 3
comparaisons.

]]> Recherche linéaire — Q11 : Meilleur cas Quelle est la complexité dans le meilleur cas
de la recherche linéaire ?

]]> Pour une recherche d'un élément aléatoirement
placé dans la liste, la complexité moyenne
est O(n / 2), souvent simplifiée en O(n) car les
constantes sont ignorées dans la notation O.

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

]]> Bonne réponse : si l'élément cherché est en
première position, on s'arrête après une
seule comparaison.

]]> O(n²)

]]> Erreur : pas de double boucle.

]]> O(log n)

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

]]> O(n)

]]> Erreur : O(n) est le pire cas.

]]> Recherche linéaire — Q12 : Variante booléenne On veut juste savoir si l'élément est présent ou
non (sans avoir besoin de l'indice). Quelle
fonction renvoie True si la cible est dans la
liste et False sinon, pour toute liste ?

]]> L'opérateur in réalise une recherche
linéaire avec arrêt au premier succès. Dans
une boucle écrite à la main, return False
ne doit venir qu'après le parcours complet.

]]> 1.0 0.0 0 true true abc

def present(liste, cible):
    return liste[cible]

]]> Erreur : liste[cible] lit l'élément
d'indice cible ; on obtient une valeur de
la liste, ou une erreur si cible n'est
pas un indice valide, mais jamais le
booléen voulu.

]]>

def present(liste, cible):
    return cible in liste

]]> Bonne réponse : l'opérateur in renvoie
directement un booléen. Il réalise la même
recherche linéaire qu'une boucle écrite à
la main.

]]>

def present(liste, cible):
    for x in liste:
        if x == cible:
            return True
        else:
            return False

]]> Erreur : le else fait sortir la fonction
dès le premier élément différent de la
cible ; present([4, 7], 7) renvoie
False.

]]>

def present(liste, cible):
    return cible == liste

]]> Erreur : on compare l'élément à la liste
entière, ce qui renvoie toujours False
(sauf cas dégénéré).

]]> Recherche linéaire — Q13 : Toutes les occurrences Pour trouver toutes les positions où la cible
apparaît dans la liste, quelle adaptation de la
recherche linéaire utilise-t-on ?

]]> Code typique :
[i for i in range(len(liste)) if liste[i] == cible].
Élégant, en une ligne, en O(n).

]]> 1.0 0.0 0 true true abc On trie d'abord entièrement la liste avant de chercher

]]> Erreur : trier modifie l'ordre et fait perdre
les positions originales.

]]> On parcourt toute la liste en enregistrant tous les indices correspondants

]]> Bonne réponse : pas d'arrêt précoce ici, on
accumule dans une liste de résultats.
Complexité : O(n) (parcours unique).

]]> On utilise une recherche dichotomique

]]> Erreur : la dichotomique trouve une
occurrence dans une liste triée, mais ne
liste pas toutes les occurrences naturellement.

]]> On s'arrête à la première occurrence et on l'enregistre

]]> Erreur : on raterait les suivantes.

]]> Recherche linéaire — Q14 : Linéaire vs dichotomique Pour rechercher un élément dans une liste triée
de 1 000 000 d'éléments, combien de comparaisons
au pire avec chacune des deux méthodes ?

]]> log₂(2¹⁰) = 10, log₂(2²⁰) = 20. Doubler la
taille de la liste ajoute juste une
comparaison à la dichotomique, mais double les
comparaisons de la linéaire.

]]> 1.0 0.0 0 true true abc Linéaire : 1 000 000 ; dichotomique : environ 20

]]> Bonne réponse : log₂(10⁶) ≈ 20. La
dichotomique est environ 50 000 fois plus rapide
dans ce cas. C'est l'intérêt majeur du tri.

]]> Linéaire : 1 000 000 ; dichotomique : 1 000

]]> Erreur : la dichotomique est en O(log n),
beaucoup plus efficace.

]]> Linéaire : 1 000 ; dichotomique : 1 000 000

]]> Erreur : valeurs inversées.

]]> Les deux sont identiques

]]> Erreur : la dichotomique est exponentiellement
plus rapide sur les grandes tailles.

]]> Recherche linéaire — Q15 : Bug d'initialisation Un élève écrit

def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            trouve = True
        else:
            trouve = False
    return trouve

Quel est le bug ?

]]> Schéma correct : initialiser un drapeau
avant la boucle, ne le mettre à True
qu'en cas de succès. Mieux : utiliser
return True direct et return False après la
boucle.

]]> 1.0 0.0 0 true true abc return doit être à l'intérieur de la boucle

]]> Erreur : ce serait un autre code, mais ce
n'est pas la cause du bug actuel.

]]> Seul le résultat de la dernière comparaison est renvoyé

]]> Bonne réponse : à chaque itération, le
else réinitialise trouve. Si la cible
est trouvée puis que la dernière itération
échoue, trouve finit à False.
Solution : initialiser trouve = False
avant la boucle, et ne faire que
trouve = True à l'intérieur (sans
else).

]]> La fonction parcourt la liste deux fois au lieu d'une

]]> Erreur : il n'y a qu'un seul parcours ; le
problème est logique, pas une question de
performance.

]]> La variable trouve n'est pas définie hors de la boucle

]]> Erreur : Python autorise (à risque) la sortie
d'une variable de boucle, tant que la
boucle s'exécute au moins une fois.

]]> Recherche linéaire — Q16 : While ou for ? Quelle est la différence pratique entre une
recherche linéaire écrite avec for et avec
while ?

]]> Bonne pratique : for pour parcourir une
structure connue ; while quand on ne sait pas
à l'avance combien d'itérations seront
nécessaires (lecture utilisateur, condition
complexe).

]]> 1.0 0.0 0 true true abc La boucle while ne permet pas de parcourir une liste

]]> Erreur : while fonctionne avec n'importe
quelle condition booléenne, y compris sur
un indice de liste.

]]> for parcourt les indices, while combine deux conditions d'arrêt

]]> Bonne réponse : while permet une condition
composée. for est plus concis quand on
itère simplement sur la longueur.

]]> La boucle for s'exécute toujours nettement plus rapidement

]]> Performance équivalente. La différence est
stylistique.

]]> Les deux sont strictement équivalents en Python

]]> Sur le plan du résultat oui, sur le plan de
la lisibilité non.

]]> Recherche linéaire — Q17 : Retrouver un nom à partir d'un numéro Le dictionnaire suivant associe à chaque nom un
numéro de téléphone :

annuaire = {"Ali": "0612", "Awa": "0745", "Tom": "0698"}

Quel moyen permet de retrouver le nom dont le
numéro est "0745" ?

]]> Dans un dictionnaire, on retrouve une valeur
à partir de sa clé, pas l'inverse. Pour
chercher une clé d'après sa valeur, on
parcourt les clés (ou annuaire.items())
et on s'arrête à la première valeur égale à
la cible.

]]> 1.0 0.0 0 true true abc Écrire annuaire["0745"], qui renvoie directement le nom associé

]]> Erreur : entre crochets, on donne une clé,
et "0745" n'est pas une clé mais une
valeur. Cette instruction provoque une
erreur.

]]> Évaluer "0745" in annuaire, qui renvoie le nom associé au numéro

]]> Erreur : in teste la présence parmi les
clés et renvoie un booléen, ici
False. Il ne renvoie jamais de nom.

]]> Parcourir les clés et comparer à "0745" la valeur associée à chacune

]]> Bonne réponse : l'accès par clé ne
fonctionne que dans le sens nom vers
numéro. Dans l'autre sens, on fait une
recherche linéaire : for nom in annuaire:
puis on teste annuaire[nom] == "0745".

]]> Faire une recherche dichotomique sur les numéros, rangés dans l'ordre croissant

]]> Erreur : rien ne garantit que les numéros
soient rangés dans l'ordre, et on ne peut
pas accéder à la valeur du milieu d'un
dictionnaire par un indice.

]]> Recherche linéaire — Q18 : Optimisation par fréquence Si l'on sait qu'un élément est plus souvent cherché que les autres, comment optimiser une
série de recherches linéaires successives ?

]]> Le nombre de comparaisons d'une recherche
linéaire dépend de la position de l'élément
cherché. C'est un bon exemple où l'ordre
des données influence la performance.

]]> 1.0 0.0 0 true true abc Trier la liste par ordre croissant

]]> Le tri n'aide pas la recherche linéaire et
demande lui-même de nombreuses comparaisons.
De plus, les éléments fréquents ne sont pas
forcément les plus petits.

]]> Doubler purement et simplement la taille de la liste

]]> Erreur : cela aggrave le problème.

]]> Placer les éléments les plus fréquents en début de liste

]]> Bonne réponse : la recherche linéaire avec
arrêt précoce trouve ces éléments après très
peu de comparaisons.

]]> Convertir la liste en chaîne

]]> Erreur : aucun gain, et in sur une chaîne
recherche les sous-chaînes, pas les
éléments.

]]> Recherche linéaire — Q19 : Recherche dans liste de tuples Soit
eleves = [("Alice", 17), ("Bob", 16), ("Eve", 18)].
Comment trouver l'âge d'Alice ?

]]> Si l'on fait souvent ce genre de recherche,
mieux vaut construire une fois pour toutes un
dictionnaire des âges :
ages = {}
for nom, age in eleves: ages[nom] = age
puis ages["Alice"] répond en O(1).

]]> 1.0 0.0 0 true true abc eleves["Alice"]]]> Erreur : eleves est une liste, pas un
dictionnaire. On ne peut pas l'indexer par
chaîne.

]]>

for nom, age in eleves:
    if nom == "Alice":
        return age

]]> Bonne réponse : on déballe chaque tuple en
deux variables, on teste le nom, on renvoie
l'âge. Recherche linéaire classique.

]]>

for nom, age in eleves:
    if nom == "Alice":
        return nom

]]> Erreur : on renvoie le nom ("Alice",
déjà connu) au lieu de l'âge. La structure
est bonne, mais la valeur renvoyée n'est
pas celle demandée : il faut return age.

]]>

for eleve in eleves:
    if eleve == "Alice":
        return eleve[1]

]]> Erreur : eleve est un tuple complet, par
exemple ("Alice", 17), jamais égal à la
chaîne "Alice" : la condition est toujours
fausse et rien n'est renvoyé. Il faut comparer
eleve[0], ou déballer le tuple en nom, age.

]]> Recherche linéaire — Q20 : Sur une chaîne L'expression "a" in "abracadabra" :

]]> Subtilité : sur une chaîne, "abc" in "ababcabc"
renvoie aussi True (sous-chaîne, pas
caractère). Sur une liste, "abc" in liste
teste l'égalité avec chaque élément.

]]> 1.0 0.0 0 true true abc Lève une exception

]]> Erreur : la syntaxe est valide.

]]> Renvoie False

]]> Erreur : "a" apparaît bien dans
"abracadabra".

]]> Renvoie le nombre d'occurrences

]]> Erreur : in renvoie un booléen, pas un
entier. Pour le comptage, utiliser .count().

]]> Renvoie True

]]> Bonne réponse : in sur une chaîne fait une
recherche de sous-chaîne (pas de
caractère unique seulement). "a" est
présent comme sous-chaîne.

]]> Recherche linéaire — Q21 : Bug : oubli de l'arrêt

def trouver(liste, cible):
    indice = -1
    for i in range(len(liste)):
        if liste[i] == cible:
            indice = i
    return indice

Quel est le comportement de cette fonction si la
cible apparaît plusieurs fois ?

]]> Cas piège mais utile : ce code peut être correct
si l'on cherche la dernière occurrence. Pour
la version classique « première occurrence », on
écrit return i à la place de indice = i : la
fonction s'arrête dès la première correspondance.

]]> 1.0 0.0 0 true true abc Elle renvoie -1

]]> Erreur : -1 est l'initialisation, mais elle
est écrasée si une correspondance existe.

]]> Elle renvoie l'indice de la dernière occurrence

]]> Bonne réponse : la boucle continue jusqu'au
bout, et indice = i écrase la valeur à
chaque correspondance. À la fin, c'est la
dernière occurrence qui reste.

]]> Elle entre dans une boucle infinie

]]> Erreur : for sur range est borné.

]]> Elle renvoie l'indice de la première occurrence

]]> Erreur : rien n'arrête la boucle à la
première correspondance : il faudrait
écrire return i dès que liste[i] == cible.

]]> Recherche linéaire — Q22 : Choisir le bon algorithme Pour rechercher un élément dans une liste de
100 éléments, non triée, qu'on ne consultera
qu'une seule fois, quelle stratégie est la plus
efficace globalement ?

]]> Règle générale : prétraiter (trier, indexer)
n'est rentable qu'au-delà d'un certain nombre
de recherches. Pour une recherche unique, la
linéaire est imbattable en simplicité.

]]> 1.0 0.0 0 true true abc Recherche linéaire directement

]]> Bonne réponse : pour une seule
recherche, la linéaire (au plus 100
comparaisons) est plus rapide que tri +
dichotomie. L'investissement du tri n'est
rentable que pour de multiples
recherches.

]]> Convertir en dictionnaire

]]> Erreur : construire le dictionnaire demande
déjà de parcourir toute la liste. Pour une
seule recherche, le gain est nul.

]]> Faire la recherche en parallèle sur 4 cœurs

]]> Sur 100 éléments, le coût de
parallélisation dépasse largement le coût
de la recherche.

]]> Trier puis dichotomie

]]> Erreur : trier 100 éléments par sélection
coûte $100 \times 99 / 2 = 4\,950$
comparaisons, plus 7 pour la dichotomie,
contre 100 au plus pour la recherche
linéaire. Pas rentable pour une seule
recherche.

]]> Recherche linéaire — Q23 : Boucle while à bug

def chercher(liste, cible):
    i = 0
    while liste[i] != cible:
        i += 1
    return i

Quel problème pose ce code ?

]]> Bug très classique. Pour les boucles while,
toujours vérifier deux choses : la condition
d'arrêt et l'évolution de la variable de
boucle (pour éviter une boucle infinie ou un
dépassement).

]]> 1.0 0.0 0 true true abc Aucun, ce code est correct pour toutes les entrées

]]> Erreur : il y a un bug majeur lié au cas
d'absence de la cible.

]]> La fonction ne renvoie jamais rien, même si la cible est présente

]]> Erreur : elle renvoie i quand elle trouve
la cible.

]]> Si l'élément est absent, la boucle dépasse la liste et lève IndexError

]]> Bonne réponse : il manque la condition
i < len(liste) dans le while. Sans cela,
on accède à liste[len(liste)] qui n'existe
pas. Solution :
while i < len(liste) and liste[i] != cible:.

]]> Le code modifie accidentellement le contenu de la liste

]]> Erreur : aucune modification de la liste.

]]> Recherche linéaire — Q24 : Comparer en pratique Sur ma machine, une recherche linéaire dans une
liste de 1 million d'éléments prend environ 30 ms. Que
prendra une recherche dans une liste de 1 milliard
d'éléments (si la mémoire le permet) ?

]]> Compétence essentielle : savoir extrapoler le
temps d'exécution selon la complexité. La
recherche linéaire devient gênante au-delà de
quelques millions d'éléments si elle est
répétée.

]]> 1.0 0.0 0 true true abc Environ 60 ms

]]> Erreur : 1 milliard, c'est mille fois plus
que 1 million, pas deux fois. Le temps est
donc multiplié par 1000, pas par 2.

]]> Environ 30 secondes

]]> Bonne réponse : O(n) → temps proportionnel.
1 milliard / 1 million = 1000, donc 30 ms ×
1000 = 30 secondes. Cette estimation est précieuse
pour anticiper les performances.

]]> Environ 8 heures

]]> Erreur : ce serait l'ordre de grandeur d'une
complexité quadratique (facteur
1000² = 10⁶, soit 30 ms × 10⁶ ≈ 8 h). La
recherche linéaire ne croît que d'un
facteur 1000.

]]> Toujours environ 30 ms

]]> Erreur : ce serait un temps constant.
O(n) signifie que le temps croît
proportionnellement à n.

]]> Recherche linéaire — Q25 : Synthèse Parmi les affirmations suivantes sur la recherche
linéaire, laquelle est fausse ?

]]> Maxime : « Pas d'algorithme universellement
meilleur. » Le choix dépend des hypothèses
(liste triée ?), du nombre de recherches, et
de la taille des données.

]]> 1.0 0.0 0 true true abc En Python, l'opérateur in sur une liste fait une recherche linéaire

]]> Vrai : in sur une liste est en O(n) ; sur
les clés d'un dictionnaire, il est en O(1)
en moyenne.

]]> Elle fonctionne sur des listes triées comme non triées

]]> Vrai : c'est l'avantage majeur sur la
dichotomique.

]]> Sa complexité au pire est O(n)

]]> Vrai : parcours complet de la liste.

]]> Elle est toujours plus rapide que la dichotomique

]]> Faux (donc bonne réponse) : sur une liste
triée et de grande taille, la dichotomique
(O(log n)) est exponentiellement plus
rapide. La linéaire reste compétitive sur
des petites listes ou pour une recherche
unique.

]]> Recherche linéaire — Q26 : Compter les occurrences On veut compter combien de fois la cible
apparaît dans la liste (et non simplement la
trouver). Quelle adaptation de la recherche
linéaire faut-il faire ?

]]> Différence essentielle avec la recherche d'une
occurrence : on ne peut pas s'arrêter au premier
succès, donc le pire cas et le meilleur cas sont
identiques, avec n comparaisons.

]]> 1.0 0.0 0 true true abc

def compter(liste, cible):
    for x in liste:
        if x == cible:
            return 1
    return 0

]]> Erreur classique : on s'arrête à la première
occurrence et on renvoie toujours 0 ou 1, ce
qui revient à un test d'appartenance, pas à
un comptage.

]]>

def compter(liste, cible):
    if cible in liste:
        return len(liste)
    else:
        return 0

]]> Erreur grossière : si la cible apparaît au
moins une fois, on renvoie la longueur
totale de la liste (donc tous les éléments
sont comptés, même ceux qui ne sont pas la
cible).

]]>

def compter(liste, cible):
    n = 0
    for x in liste:
        if x == cible:
            n += 1
    return n

]]> Bonne réponse : on parcourt toute la
liste sans arrêt précoce et on incrémente un
compteur à chaque correspondance. Le coût
est linéaire.

]]>

def compter(liste, cible):
    for x in liste:
        n = 0
        if x == cible:
            n += 1
    return n

]]> Erreur : n = 0 est placé dans la boucle,
donc le compteur repart de zéro à chaque
tour. La fonction renvoie 1 si le dernier
élément est la cible et 0 sinon, et
provoque une erreur sur une liste vide.

]]> Recherche linéaire — Q27 : Recherche par condition On cherche le premier élément d'une liste de
nombres qui soit strictement supérieur à
100 (et son indice). Quel code applique
correctement la recherche linéaire à ce cas ?

]]> Schéma général de la recherche linéaire par
condition : le test d'égalité liste[i] == cible
est remplacé par n'importe quelle condition sur
liste[i] ; le reste du parcours (arrêt au
premier succès, valeur renvoyée en cas
d'absence) est inchangé.

]]> 1.0 0.0 0 true true abc

def premier_grand(liste):
    triee = sorted(liste)
    return triee[len(triee) - 1]

]]> Erreur double : on trie une copie de la
liste, ce qui coûte un tri complet, puis on
renvoie le maximum, qui n'est pas forcément
le premier élément supérieur à 100 dans
l'ordre original. L'indice n'est pas non
plus renvoyé.

]]>

def premier_grand(liste):
    for i in range(len(liste)):
        if liste[i] > 100:
            return True
    return False

]]> Erreur de spécification : ce code répond à
la question « existe-t-il un élément
supérieur à 100 ? » par un booléen, alors
qu'on demande cet élément et son indice. Le
parcours est le bon, mais la valeur
renvoyée ne l'est pas.

]]>

def premier_grand(liste):
    for x in liste:
        if x > 100:
            return x
        return None

]]> Erreur d'indentation : return None est
dans la boucle, donc la fonction sort dès le
premier élément (qui est rarement supérieur
à 100). De plus, on ne renvoie pas l'indice.

]]>

def premier_grand(liste):
    for i in range(len(liste)):
        if liste[i] > 100:
            return (i, liste[i])
    return None

]]> Bonne réponse : la recherche linéaire se
généralise à n'importe quelle condition. On
parcourt les indices, on teste la condition
sur liste[i], on renvoie le couple (indice,
valeur) dès le premier succès, et None si
aucun élément ne convient.

]]> Recherche linéaire — Q28 : Recherche dans un tableau à deux dimensions On dispose d'une matrice carrée représentée par
une liste de listes (par exemple
m = [[3, 7, 1], [8, 2, 5], [4, 9, 6]]). On
cherche le couple (ligne, colonne) de la
première occurrence de la valeur 5. Quel code
est correct ?

]]> Ce code fonctionne aussi pour une matrice non
carrée, puisque len(m[i]) est la longueur de
la ligne courante. Le return (i, j) sort des
deux boucles d'un coup : c'est l'intérêt
d'écrire cette recherche dans une fonction.

]]> 1.0 0.0 0 true true abc

def chercher(m, cible):
    for i in range(len(m)):
        for j in range(len(m[i])):
            if m[i][j] == cible:
                return (i, j)
        return None

]]> Erreur : return None est placé dans la
boucle sur les lignes, donc la fonction
abandonne après avoir examiné la première
ligne. Avec la matrice donnée, 5 est en
ligne 1 et l'appel renvoie None.

]]>

def chercher(m, cible):
    for ligne in m:
        for x in ligne:
            if x == cible:
                return x
    return None

]]> Erreur : on renvoie la valeur trouvée
(ce qui est trivial puisqu'on connaît
déjà la cible), pas le couple de
coordonnées demandé. Il faut parcourir
les indices i et j avec range pour
pouvoir renvoyer le couple (i, j).

]]>

def chercher(m, cible):
    for i in range(len(m)):
        if m[i] == cible:
            return i
    return None

]]> Erreur : on compare une ligne entière à
la cible (un nombre), ce qui sera toujours
faux. On confond élément de la matrice et
ligne.

]]>

def chercher(m, cible):
    for i in range(len(m)):
        for j in range(len(m[i])):
            if m[i][j] == cible:
                return (i, j)
    return None

]]> Bonne réponse : double boucle imbriquée pour
parcourir lignes et colonnes, retour
précoce dès la cible trouvée. Pour la
matrice donnée, on renvoie (1, 2).
Complexité O(L × C) où L est le nombre de
lignes et C le nombre de colonnes.

]]> Recherche linéaire — Q29 : Le nombre de comparaisons pour un élément présent Une recherche linéaire parcourt une liste de $10$ éléments depuis
le début et s'arrête dès qu'elle trouve la valeur cherchée. Cette
valeur se trouve en position $7$, en comptant à partir de $1$.
Combien de comparaisons sont effectuées ?

]]> Le coût d'une recherche linéaire dépend de la position de la
valeur : au mieux $1$, au pire $n$.

]]> 1.0 0.0 0 true true abc $7$

]]> Bonne réponse : chaque élément examiné coûte une comparaison, du
premier jusqu'à celui qui est trouvé, soit $7$.

]]> $10$

]]> Erreur : la recherche s'arrête dès que la valeur est trouvée,
sans examiner la fin de la liste.

]]> $6$

]]> Erreur : la comparaison qui trouve l'élément compte aussi.

]]> $8$

]]> Erreur : une fois la valeur trouvée, aucune comparaison
supplémentaire n'a lieu.

]]> Recherche linéaire — Q30 : Le nombre de comparaisons pour un élément absent Une recherche linéaire cherche une valeur absente d'une liste de
$1\,000$ éléments. Combien de comparaisons effectue-t-elle ?

]]> L'absence est le pire cas de la recherche linéaire : $n$
comparaisons pour $n$ éléments.

]]> 1.0 0.0 0 true true abc $1\,000$

]]> Bonne réponse : pour conclure à l'absence, il faut avoir
comparé la valeur à chaque élément, sans exception.

]]> $500$

]]> Erreur : la moitié serait un coût moyen pour une valeur
présente ; une valeur absente oblige à tout parcourir.

]]> $1$

]]> Erreur : une seule comparaison ne permet pas d'affirmer que la
valeur n'est nulle part.

]]> $2\,000$

]]> Erreur : chaque élément n'est comparé qu'une fois.

]]> Recherche linéaire — Q31 : Le coût moyen d'une recherche Une liste contient $1\,000$ éléments et la valeur cherchée s'y trouve,
à une position aussi probable qu'une autre. Combien de comparaisons
la recherche linéaire effectue-t-elle en moyenne ?

]]> Meilleur cas, pire cas et cas moyen décrivent trois situations. Pour
la recherche linéaire, le cas moyen reste proportionnel à $n$.

]]> 1.0 0.0 0 true true abc Environ $500$

]]> Bonne réponse : la position va de $1$ à $1\,000$ avec la même
probabilité ; la moyenne des coûts est à peu près la moitié de
$1\,000$.

]]> $1\,000$

]]> Erreur : $1\,000$ est le pire cas, quand la valeur est en dernière
position ou absente.

]]> $1$

]]> Erreur : $1$ est le meilleur cas, quand la valeur est en tête.

]]> Environ $\log_2 1\,000$

]]> Erreur : le coût logarithmique est celui de la recherche
dichotomique, sur une liste triée.

]]> Recherche linéaire — Q32 : Une liste deux fois plus longue Sur une liste de un million d'éléments, une recherche linéaire dans le pire
cas prend $2$ s. Combien de temps prend-elle, toujours dans le
pire cas, sur une liste de deux millions d'éléments ?

]]> Dire qu'un coût est linéaire, c'est dire que le temps suit la
taille des données : multiplier l'une par deux multiplie l'autre
par deux.

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

]]> Bonne réponse : le coût est proportionnel au nombre d'éléments.
Deux fois plus d'éléments, deux fois plus de comparaisons, deux
fois plus de temps.

]]> Toujours $2$ s

]]> Erreur : chaque élément supplémentaire est une comparaison de
plus ; le temps augmente.

]]> Environ $2 + 1$ s

]]> Erreur : le temps ne croît pas d'une constante mais
proportionnellement à la taille.

]]> Environ $2 \times 2$ s

]]> Erreur : le coût n'est pas quadratique ; doubler la taille
double le temps, il ne le met pas au carré.

]]> Recherche linéaire — Q33 : La dernière position d'une valeur Qu'affiche ce programme ?

def derniere(t, x):
    pos = -1
    for i in range(len(t)):
        if t[i] == x:
            pos = i
    return pos

print(derniere([4, 7, 4, 9, 4, 1], 4))

]]> Une recherche linéaire sans return dans la boucle parcourt toute
la liste : elle trouve la dernière occurrence au lieu de la
première.

]]> 1.0 0.0 0 true true abc 4

]]> Bonne réponse : sans arrêt anticipé, pos est réécrit à chaque
occurrence et garde l'indice de la dernière, 4.

]]> 0

]]> Erreur : 0 est l'indice de la première occurrence ; la
boucle continue après.

]]> 3

]]> Erreur : 3 est le nombre d'occurrences, mais pos mémorise
un indice.

]]> -1

]]> Erreur : -1 ne reste que si la valeur est absente.

]]> Recherche linéaire — Q34 : La position du maximum Qu'affiche ce programme ?

def position_max(t):
    im = 0
    for i in range(1, len(t)):
        if t[i] > t[im]:
            im = i
    return im

print(position_max([3, 8, 2, 8, 5]))

]]> Chercher la position du maximum est une recherche linéaire avec
mémoire : on retient l'indice du meilleur candidat rencontré.

]]> 1.0 0.0 0 true true abc 1

]]> Bonne réponse : im ne change qu'en cas de valeur strictement
plus grande ; en cas d'égalité, la première occurrence du
maximum est conservée.

]]> 8

]]> Erreur : 8 est la valeur maximale ; la fonction renvoie son
indice.

]]> 3

]]> Erreur : avec > strict, la dernière occurrence du maximum ne
remplace pas la première.

]]> 0

]]> Erreur : im part de 0 mais est remplacé dès qu'une valeur plus
grande apparaît.

]]> Recherche linéaire — Q35 : L'indice renvoyé en cas de répétition La fonction recherche(t, x) renvoie l'indice du premier élément
égal à x, ou -1 s'il n'y en a pas. Que renvoie
recherche([5, 6, 7, 6], 6) ?

]]> En cas de répétition, la recherche linéaire classique renvoie la
première occurrence, celle qui arrête le parcours.

]]> 1.0 0.0 0 true true abc 1

]]> Bonne réponse : la valeur 6 apparaît plusieurs fois, et la
recherche s'arrête à la première, d'indice 1.

]]> 3

]]> Erreur : 3 est l'indice de la dernière occurrence ; la
recherche s'arrête à la première.

]]> 6

]]> Erreur : la fonction renvoie un indice, pas la valeur cherchée.

]]> -1

]]> Erreur : -1 n'est renvoyé que si la valeur est absente.

]]> Recherche linéaire — Q36 : La place du return final Dans cette fonction, pourquoi return -1 est-il placé après la
boucle et non à l'intérieur ?

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

]]> Un return dans la boucle signale le succès ; le return après la
boucle signale l'échec, une fois tous les éléments examinés.

]]> 1.0 0.0 0 true true abc Pour ne conclure à l'absence qu'après la fin du parcours

]]> Bonne réponse : return -1 n'est atteint que si la boucle s'est
terminée sans trouver x. Placé dans la boucle, il
interromprait la recherche dès le premier élément différent.

]]> Pour que la fonction renvoie toujours -1 en dernier

]]> Erreur : si x est trouvé, return i sort de la fonction avant
d'atteindre return -1.

]]> Parce qu'un return est interdit dans une boucle

]]> Erreur : return i est précisément dans la boucle, et c'est
permis.

]]> Pour économiser une comparaison à chaque tour de boucle

]]> Erreur : la position du return final ne change pas le nombre de
comparaisons.

]]>