$course$/QCM de NSI/Terminale/Recherche textuelle Recherche d'un motif dans un texte, algorithme naïf (force
brute), algorithme de Boyer-Moore-Horspool (comparaison de
droite à gauche, table de décalages), pré-traitement,
complexités, applications (grep, Ctrl+F, ADN).

]]> Recherche textuelle — Q01 : Position du problème En quoi consiste la recherche textuelle ?

]]> La recherche textuelle est un problème fondamental en
informatique : elle est utilisée des milliards de fois
par jour (recherche web, éditeurs de texte, analyse de
données massives).

]]> 1.0 0.0 0 true true abc Compter le nombre de caractères dans un texte

]]> Erreur : ce n'est pas une recherche, juste un
comptage trivial.

]]> Chercher un mot dans un dictionnaire trié

]]> Erreur : c'est un cas particulier qui se résout par
recherche dichotomique. La recherche textuelle est
plus générale.

]]> Trouver toutes les positions d'un motif dans un texte

]]> Bonne réponse : c'est exactement le problème étudié.
Applications : Ctrl+F dans un éditeur, grep,
analyse de séquences ADN, moteurs de recherche.

]]> Trier entièrement un texte par ordre alphabétique

]]> Erreur : aucun rapport avec le tri.

]]> Recherche textuelle — Q02 : Principe de l'algorithme naïf Quel est le principe de l'algorithme naïf (force brute) ?

]]> L'algorithme naïf est simple mais inefficace : il
avance toujours d'une seule position après chaque
échec, même quand le premier caractère ne correspondait
pas.

]]> 1.0 0.0 0 true true abc On découpe le texte en deux et on cherche dans chaque moitié

]]> Erreur : ce serait du « diviser pour régner », ce
que ne fait pas l'algorithme naïf.

]]> On compare le motif uniquement à la fin du texte

]]> Erreur : on teste toutes les positions, pas
seulement la fin.

]]> On teste chaque position de départ et on compare caractère par caractère

]]> Bonne réponse : pour chaque indice i de 0 à
n - m, on compare le motif au texte à partir de
la position i. Dès qu'un caractère diffère, on
passe à la position suivante.

]]> On compare depuis la fin du motif et on saute plusieurs positions

]]> Erreur : c'est l'idée de l'algorithme de Boyer-Moore. L'algorithme naïf compare de gauche à droite et n'avance que d'une position après chaque échec.

]]> Recherche textuelle — Q03 : Borne de la boucle Dans l'algorithme naïf, la boucle externe va de 0 à
quelle valeur (incluse) pour pouvoir aligner un motif
de longueur m dans un texte de longueur n ?

]]> Erreur classique : oublier le +1 dans range. Pour
éviter ce piège, vérifier sur un petit exemple :
texte = "abc", motif = "bc", longueurs n=3,
m=2. Positions valides : 0, 1. Donc range(2) =
range(n - m + 1).

]]> 1.0 0.0 0 true true abc n - m

]]> Bonne réponse : c'est la dernière position où le
motif tient encore dans le texte. En Python, on
écrit donc range(n - m + 1) (la borne supérieure
de range étant exclusive).

]]> n

]]> Erreur : la position n n'existe même pas dans le
texte.

]]> n - m - 1

]]> Erreur : on raterait la dernière position valide
(le motif placé à la toute fin du texte).

]]> n - 1

]]> Erreur : on dépasserait la fin du texte. À la
position n - 1, il ne reste qu'un caractère pour
aligner les m caractères du motif.

]]> Recherche textuelle — Q04 : Complexité du naïf Quelle est la complexité dans le pire cas de
l'algorithme naïf de recherche textuelle ?

]]> Le pire cas se rencontre par exemple avec un texte
"aaaa...a" et un motif "aaab" : à chaque position,
les m-1 premiers caractères correspondent avant
l'échec, soit ~ n × m comparaisons.

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

]]> Erreur : aucune dichotomie dans cet algorithme.

]]> O(n × m)

]]> Bonne réponse : la boucle externe parcourt environ
n positions ; pour chacune, on peut faire jusqu'à
m comparaisons. D'où O(n × m), souvent noté
O(n²) quand n ≫ m.

]]> O(n)

]]> Erreur : O(n) supposerait une seule comparaison
par position, ce qui n'est pas le cas dans le
pire cas.

]]> O(n + m)

]]> Erreur : un coût en O(n + m) supposerait de ne jamais revenir sur les caractères déjà comparés. L'algorithme naïf peut refaire jusqu'à m comparaisons à chacune des positions du texte.

]]> Recherche textuelle — Q05 : Idée clé de Boyer-Moore Quelle est l'idée centrale de l'algorithme de
Boyer-Moore-Horspool ?

]]> Comparer de droite à gauche peut sembler contre-intuitif,
mais c'est précisément ce qui permet de tirer parti des
caractères « rares » dans le motif pour faire de grands
sauts.

]]> 1.0 0.0 0 true true abc Comparer le motif de gauche à droite mais en sautant les voyelles

]]> Erreur : aucun rapport avec les voyelles. La
comparaison va de droite à gauche.

]]> Utiliser la programmation dynamique avec une mémoïsation complète

]]> Erreur : Boyer-Moore n'utilise pas de mémoïsation.

]]> Comparer le motif de droite à gauche et sauter en cas d'échec via une table de décalages

]]> Bonne réponse : ces deux idées combinées
permettent d'éviter de comparer chaque caractère
du texte. Dans le meilleur cas, on saute m
positions à chaque fois.

]]> Pré-trier le texte pour faire une recherche dichotomique

]]> Erreur : on ne peut pas trier un texte sans
détruire sa structure. La recherche dichotomique
ne s'applique pas ici.

]]> Recherche textuelle — Q06 : Applications concrètes Lequel des outils suivants utilise une variante de la
recherche textuelle (algorithme naïf ou Boyer-Moore) ?

]]> La recherche textuelle est l'une des opérations les plus exécutées en informatique. Les implémentations réelles utilisent souvent Boyer-Moore ou des variantes de cet algorithme.

]]> 1.0 0.0 0 true true abc grep, Ctrl+F et l'analyse de séquences ADN

]]> Bonne réponse : Ctrl+F, grep et la bio-informatique
sont trois applications classiques, qui reposent
toutes sur la recherche d'un motif dans un texte. La
recherche textuelle est partout.

]]> L'analyse de séquences ADN exclusivement

]]> L'analyse de séquences ADN utilise bien la recherche
textuelle, mais ce n'est pas la seule application :
grep et Ctrl+F aussi.

]]> La commande Unix grep, et aucun autre outil

]]> grep utilise bien la recherche textuelle, mais ce
n'est pas le seul outil concerné : Ctrl+F et
l'analyse de séquences ADN aussi.

]]> La fonction Ctrl+F d'un éditeur de texte, et elle seule

]]> Ctrl+F utilise bien la recherche textuelle, mais ce
n'est pas la seule application : grep et
l'analyse de séquences ADN aussi. Lis bien toutes les
propositions.

]]> Recherche textuelle — Q07 : Que renvoie l'algorithme ? Lorsqu'on programme recherche(texte, motif), quel
est le retour le plus utile ?

]]> Renvoyer la liste des positions est la convention
standard. La méthode Python str.find() renvoie
l'indice de la première occurrence (ou -1) ; pour
toutes les occurrences, il faut écrire sa propre
fonction ou utiliser re.finditer.

]]> 1.0 0.0 0 true true abc La liste des indices de début de chaque occurrence

]]> Bonne réponse : c'est l'information la plus riche
([] si absent, [3, 7] si présent aux
positions 3 et 7). Un booléen ou un compte
peuvent en être déduits.

]]> Un booléen True/False indiquant la présence

]]> Insuffisant : on ne sait pas où est le motif,
ni combien de fois il apparaît.

]]> La longueur du motif

]]> Erreur : c'est connu d'avance via len(motif),
aucun intérêt à la renvoyer.

]]> Le texte modifié pour retirer le motif

]]> Erreur : ce serait un replace, pas une recherche.

]]> Recherche textuelle — Q08 : Trace de l'algorithme naïf Avec l'algorithme naïf, on cherche motif = "ab" dans
texte = "babab". Quel est le résultat ?

]]> Pour vérifier rapidement, surligne les caractères du
texte un par un et identifie les "ab" consécutifs.

]]> 1.0 0.0 0 true true abc [1, 3]

]]> Bonne réponse : positions 1 ("ab") et 3 ("ab").
Aux positions 0, 2, 4 le premier caractère est
"b", ce qui échoue.

]]> [0, 2]

]]> Erreur : à la position 0, on a "b" ≠ "a",
donc échec immédiat. Le motif ne commence pas en 0.

]]> [1, 2, 3]

]]> Erreur : à la position 2, le caractère est "b",
donc échec immédiat ("b" ≠ "a").

]]> []

]]> Erreur : le motif "ab" apparaît bien dans
"babab" (deux fois).

]]> Recherche textuelle — Q09 : Pire cas du naïf Lequel de ces couples (texte, motif) constitue un
pire cas pour l'algorithme naïf ?

]]> Le pire cas se rencontre quand le motif et le texte
partagent un long préfixe commun à chaque position
(ex. : alphabets très réduits, motifs « presque
identiques » au texte).

]]> 1.0 0.0 0 true true abc texte = 'abracadabra', motif = 'xyz'

]]> Au contraire : 'x' n'apparaît jamais dans le
texte, donc l'échec est immédiat (1 comparaison
par position). C'est un bon cas pour le naïf.

]]> texte = 'aaaaaaaaa', motif = 'aaab'

]]> Bonne réponse : à chaque position, les 3 premiers
caractères correspondent avant l'échec sur le
dernier. On effectue ~ 4 × n comparaisons.

]]> texte = 'hello', motif = 'hello'

]]> Erreur : ce cas se résout en m comparaisons à la
position 0. Pas de pire cas.

]]> texte = 'a', motif = 'ab'

]]> Erreur : m > n, la boucle ne s'exécute même pas.

]]> Recherche textuelle — Q10 : Direction de comparaison Dans Boyer-Moore-Horspool, par quel caractère du motif
commence-t-on la comparaison ?

]]> Comparer de droite à gauche est la clé : si le
caractère du texte aligné avec la fin du motif n'est
pas dans le motif, on peut sauter de m positions sans
risque.

]]> 1.0 0.0 0 true true abc Le caractère du milieu

]]> Erreur : aucun algorithme classique ne fait cela.

]]> Un caractère choisi au hasard

]]> Erreur : la recherche serait non déterministe.

]]> Le dernier (droite)

]]> Bonne réponse : on aligne le motif sur le texte
puis on compare d'abord motif[m-1] avec
texte[i + m - 1]. C'est ce caractère qui décide
du décalage à appliquer en cas d'échec.

]]> Le premier (gauche)

]]> Erreur : ce serait l'algorithme naïf. Boyer-Moore
fait l'inverse.

]]> Recherche textuelle — Q11 : Construction de la table Pour le motif "dab" (longueur 3), quelle est la table
de décalages de Boyer-Moore-Horspool ?

]]> Formule : pour le caractère c en position i (la plus
à droite, hors dernière position), décalage = m - 1 - i.
Caractères absents du motif : décalage = m.

]]> 1.0 0.0 0 true true abc {'d': 3, 'a': 3, 'b': 3}

]]> Erreur : la valeur 3 (= m) correspond aux
caractères absents du motif.

]]> {'d': 0, 'a': 1, 'b': 2}

]]> Erreur : ce sont les positions, pas les décalages, et il ne faut pas
inclure 'b'.

]]> {'d': 2, 'a': 1}

]]> Bonne réponse : pour 'd' en position 0, décalage = 3 - 1 - 0 = 2 ; pour 'a' en position 1, décalage = 3 - 1 - 1 = 1. Le 'b'
final est exclu.

]]> {'d': 2, 'a': 1, 'b': 0}

]]> Erreur : on n'inclut pas le dernier caractère
('b') dans la table, sinon on risque un
décalage de 0 qui ferait boucler l'algorithme.

]]> Recherche textuelle — Q12 : Caractère absent du motif Avec le motif "dab" (longueur 3), le caractère du
texte aligné avec la fin du motif est 'z'. Quel
décalage applique-t-on ?

]]> C'est le « cadeau » de Boyer-Moore : un grand alphabet
(lettres, chiffres, ponctuation) signifie beaucoup de
caractères absents du motif, donc des sauts maximaux.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : c'est le décalage par défaut de
l'algorithme naïf, mais Boyer-Moore fait mieux.

]]> 3

]]> Bonne réponse : 'z' n'apparaît pas dans "dab",
on peut donc sauter de toute la longueur du
motif (3) sans risquer de manquer une occurrence.

]]> 0

]]> Erreur : un décalage de 0 ferait boucler
l'algorithme indéfiniment.

]]> 2

]]> Erreur : 2 est le décalage pour 'd', pas pour
un caractère absent.

]]> Recherche textuelle — Q13 : Caractère répété Pour le motif "maman" (longueur 5), quelle est la
table de décalages ?

]]> Quand un caractère apparaît plusieurs fois dans le
motif, on garde la dernière occurrence (avant la fin)
car elle donne le plus petit décalage sûr.

]]> 1.0 0.0 0 true true abc {'m': 2, 'a': 3}

]]> Erreur : ce sont les positions des caractères, pas les
décalages ; le décalage vaut 5 - 1 - position.

]]> {'m': 4, 'a': 3}

]]> Erreur : 'm' apparaît plusieurs fois, on
ne garde que la position la plus à droite
(hors dernière position), ici 2.

]]> {'m': 2, 'a': 1}

]]> Bonne réponse : 'm' en position 2, décalage 5 - 1 - 2 = 2 ; 'a' en position 3, décalage 5 - 1 - 3 = 1.

]]> {'m': 2, 'a': 1, 'n': 0}

]]> Erreur : on n'inclut pas le dernier caractère
('n').

]]> Recherche textuelle — Q14 : Pourquoi exclure le dernier caractère ? Pourquoi exclut-on le dernier caractère du motif lors
du pré-traitement ?

]]> C'est un point subtil mais essentiel. Sans cette
exclusion, l'algorithme entrerait dans une boucle
infinie dès qu'on rencontre un caractère identique au
dernier du motif.

]]> 1.0 0.0 0 true true abc Parce qu'un décalage de 0 ferait boucler l'algorithme

]]> Bonne réponse : en cas d'égalité avec le dernier
caractère du motif, on veut chercher la
précédente occurrence (à gauche), ou décaler de
m s'il n'y en a pas. Décaler de 0 ferait revenir
à la même position et boucler.

]]> Pour économiser une quantité notable de mémoire

]]> Erreur : le gain mémoire est négligeable. La
vraie raison est algorithmique.

]]> Parce que Python ne permet pas d'indexer la dernière position

]]> Erreur : Python le permet sans problème.

]]> Parce qu'il est toujours absent du motif

]]> Erreur : il fait évidemment partie du motif
(puisqu'il en est le dernier caractère).

]]> Recherche textuelle — Q15 : Trace de Boyer-Moore On cherche motif = "dab" dans texte = "abracadabra".
Au premier alignement (i=0), on compare texte[2]
('r') avec motif[2] ('b'). Échec. Sachant que
'r' n'est pas dans le motif, de combien décale-t-on ?

]]> C'est précisément ce type de saut qui fait la
puissance de Boyer-Moore : sur du texte naturel
(alphabet riche), de tels sauts maximaux sont
fréquents.

]]> 1.0 0.0 0 true true abc 3 (la longueur du motif)

]]> Bonne réponse : 'r' est absent de "dab", on
saute de m = 3 positions. La nouvelle position
devient i = 3.

]]> 11 (la longueur du texte)

]]> Erreur : on n'a aucune raison de sauter à la fin
du texte.

]]> 1

]]> Erreur : ce serait l'algorithme naïf. Boyer-Moore
tire parti de l'absence de 'r' dans le motif.

]]> 2

]]> Erreur : 2 est le décalage de 'd', pas d'un
caractère absent.

]]> Recherche textuelle — Q16 : Prétraiter le motif plutôt que le texte Avant de parcourir le texte, l'algorithme de Boyer-Moore calcule une table de décalages. Pourquoi ce prétraitement porte-t-il sur le motif et non sur le texte ?

]]> La table indique, pour chaque caractère, de combien décaler le motif lorsque ce caractère se trouve en face de la dernière position du motif. Elle ne dépend que du motif : on la calcule une seule fois, et on peut même la réutiliser pour chercher le même motif dans plusieurs textes.

]]> 1.0 0.0 0 true true abc La table du texte serait identique à celle du motif

]]> Erreur : le texte contient en général d'autres caractères, à d'autres positions, que le motif. Une table construite sur le texte n'aurait rien à voir avec celle du motif.

]]> Le motif est modifié pendant la recherche et doit donc être préparé

]]> Erreur : le motif n'est jamais modifié pendant la recherche. La table est seulement lue pour savoir de combien décaler le motif.

]]> Le motif est court et connu d'avance : sa table sert à chaque échec

]]> Bonne réponse : la table se calcule en un seul passage sur les m caractères du motif, puis elle est consultée à chaque échec, quelle que soit la longueur du texte parcouru.

]]> Le texte ne peut pas être lu avant la recherche proprement dite

]]> Erreur : rien n'empêche de lire le texte à l'avance. Mais le préparer demanderait de le parcourir en entier, ce que la recherche cherche justement à éviter.

]]> Recherche textuelle — Q17 : Table produite par le code du prétraitement On considère la fonction suivante, qui construit la table de décalages de Boyer-Moore-Horspool :
`python
def table_decalages(motif):
m = len(motif)
table = {}
for i in range(m - 1):
table[motif[i]] = m - 1 - i
return table
print(table_decalages("RIRE"))
`
Qu'affiche ce programme ?

]]> La table associe à chaque caractère du motif, sauf le dernier, sa distance à la fin du motif. Quand un caractère apparaît plusieurs fois, la dernière affectation l'emporte : on garde le plus petit décalage, le seul qui ne risque pas de faire manquer une occurrence.

]]> 1.0 0.0 0 true true abc {'R': 1, 'I': 2}

]]> Bonne réponse : avec m = 4, l’indice 0 associe R à 3, l’indice 1 associe I à 2, l’indice 2 associe R à 1 ; la dernière affectation pour R remplace la valeur 3.

]]> {'R': 2, 'I': 1}

]]> Erreur : tu ranges l'indice i au lieu de m - 1 - i. La valeur stockée est la distance entre le caractère et la dernière position du motif.

]]> {'R': 1, 'I': 2, 'E': 0}

]]> Erreur : la boucle for i in range(m - 1) s'arrête à l'indice 2. Le dernier caractère, E, n'est jamais traité.

]]> {'R': 3, 'I': 2}

]]> Erreur : tu gardes la valeur de la première apparition de R. La boucle rencontre R une seconde fois, à l'indice 2, et l'affectation table['R'] = 1 remplace l'ancienne valeur.

]]> Recherche textuelle — Q18 : Quand BM n'apporte rien Dans quel cas Boyer-Moore-Horspool n'apporte-t-il
aucun gain par rapport à l'algorithme naïf ?

]]> Règle empirique : Boyer-Moore est efficace si motif
long + alphabet varié. Les pires cas se rencontrent
avec des séquences quasi-uniformes (séquences ADN
avec un seul nucléotide, par exemple).

]]> 1.0 0.0 0 true true abc Quand le motif cherché est court (trois ou quatre caractères)

]]> Partiellement vrai : les sauts sont limités à m,
donc le gain est modeste, mais il existe. Ce n'est
pas le pire cas.

]]> Quand le texte parcouru est très long (plusieurs mégaoctets)

]]> Erreur : au contraire, plus le texte est long,
plus l'écart en valeur absolue grandit.

]]> Quand l'alphabet utilisé est particulièrement large

]]> Erreur : c'est le cas favorable à
Boyer-Moore (sauts maximaux fréquents).

]]> Quand texte et motif sont presque uniformes (que des 'a')

]]> Bonne réponse : quand texte et motif n'ont presque
que des caractères identiques, l'alphabet utile est
réduit, les décalages sont presque toujours de 1 et
on retombe sur un parcours position par position.

]]> Recherche textuelle — Q19 : Majuscules et minuscules dans la recherche La fonction recherche_naif(texte, motif) renvoie la liste des indices où le motif apparaît, en comparant les caractères un à un avec ==. Que renvoie l'appel recherche_naif("Le Chat dort", "chat") ?

]]> La recherche textuelle compare des caractères, et une majuscule n'est pas le même caractère que la minuscule correspondante. Pour trouver "Chat" quelle que soit son écriture, on peut convertir le texte et le motif avec lower() avant la recherche.

]]> 1.0 0.0 0 true true abc [3]

]]> Erreur : "Chat" commence bien à l'indice 3, mais C et c sont deux caractères différents, de codes 67 et 99. La comparaison échoue dès le premier caractère du motif.

]]> Une erreur, car le texte contient des espaces

]]> Erreur : l'espace est un caractère comme un autre. Il est simplement comparé aux caractères du motif, sans provoquer d'erreur.

]]> []

]]> Bonne réponse : la comparaison == distingue C (code 67) de c (code 99). Aucune position du texte ne correspond entièrement au motif "chat".

]]> [4]

]]> Erreur : tu numérotes les caractères à partir de 1 et tu négliges la différence entre majuscule et minuscule. En réalité, aucune position ne convient.

]]> Recherche textuelle — Q20 : Un motif plus long, moins d'alignements Un texte de 60 caractères ne contient que des points. On y cherche avec Boyer-Moore-Horspool d'abord le motif "abc", puis le motif "abcdef". Combien d'alignements l'algorithme examine-t-il dans chacun des deux cas ?

]]> Le point est absent des deux motifs : à chaque alignement, la première comparaison échoue et le motif saute de toute sa longueur. Plus le motif est long, plus les sauts sont grands, et moins l'algorithme examine d'alignements.

]]> 1.0 0.0 0 true true abc 60 puis 60

]]> Erreur : l'algorithme ne s'aligne pas sur chaque caractère du texte. Chaque échec provoque un saut de toute la longueur du motif, puisque le point en est absent.

]]> 20 puis 10

]]> Bonne réponse : avec "abc", les alignements sont 0, 3, 6, …, 57, soit 20 ; avec "abcdef", ce sont 0, 6, 12, …, 54, soit 10.

]]> 58 puis 55

]]> Erreur : 58 et 55 sont les nombres de positions testées par l'algorithme naïf, qui avance d'une seule position à chaque échec. Boyer-Moore saute bien plus loin.

]]> 20 puis 40

]]> Erreur : tu penses qu'un motif plus long demande plus d'alignements. C'est l'inverse : le point étant absent du motif, chaque échec fait sauter le motif de toute sa longueur, donc de 6 pour "abcdef".

]]> Recherche textuelle — Q21 : Nombre d'alignements de BM On cherche motif = "dab" (longueur 3) dans
texte = "abracadabra" (longueur 11) avec
Boyer-Moore-Horspool. Combien d'alignements distincts
du motif sont effectués (i.e. valeurs successives de
i) avant la fin de l'algorithme ?

]]> Trace complète : i=0, échec sur 'r' (saute 3) ; i=3,
échec sur 'a' (saute 1) ; i=4, échec sur 'd' (saute
2) ; i=6, succès. Quatre alignements pour 9 dans le
naïf : économie de plus de la moitié.

]]> 1.0 0.0 0 true true abc 2

]]> Erreur : trop peu, on doit bien tester plusieurs
positions intermédiaires.

]]> 9 (comme l'algorithme naïf)

]]> Erreur : Boyer-Moore fait moins d'alignements
grâce aux sauts.

]]> 4

]]> Bonne réponse : i = 0 → saute de 3 → i = 3 →
saute de 1 → i = 4 → saute de 2 → i = 6 (motif
trouvé) → i = 7 → fin. Soit 4 alignements
distincts (0, 3, 4, 6) avant détection.

]]> 11

]]> Erreur : on ne teste pas chaque position du
texte (c'est tout l'intérêt de Boyer-Moore).

]]> Recherche textuelle — Q22 : Table d'un motif complexe Quelle est la table de décalages de
Boyer-Moore-Horspool pour le motif "abracadabra"
(longueur 11) ?

]]> Méthode systématique : balayer le motif de droite à
gauche en s'arrêtant avant le dernier caractère.
Pour chaque nouveau caractère rencontré, calculer
m - 1 - i.

]]> 1.0 0.0 0 true true abc {'a': 3, 'b': 2, 'r': 1, 'c': 6, 'd': 4}

]]> Bonne réponse. Dernière position (hors fin) de
chaque caractère : a en 7 → 11-1-7=3 ; b en 8 → 11-1-8=2 ; r en 9 → 11-1-9=1 ; c en 4 → 11-1-4=6 ; d en 6 → 11-1-6=4. Le 'a' final est exclu.

]]> {'a': 0, 'b': 2, 'r': 1, 'c': 6, 'd': 4}

]]> Erreur : le 'a' final est exclu ; sa dernière
position retenue est celle qui précède la fin du motif.

]]> {'a': 7, 'b': 8, 'r': 9, 'c': 4, 'd': 6}

]]> Erreur : ce sont les positions, pas les
décalages. Le décalage est m - 1 - position.

]]> {'a': 10, 'b': 9, 'r': 8, 'c': 6, 'd': 4}

]]> Erreur : ce sont les décalages calculés sur la
première position de chaque caractère. Il faut
prendre la dernière position (hors fin).

]]> Recherche textuelle — Q23 : Le texte qui ralentit Boyer-Moore On cherche le motif "ABCD" avec Boyer-Moore-Horspool dans un texte formé de 20 fois la même lettre. Pour lequel des textes suivants l'algorithme examine-t-il le plus d'alignements ?

]]> Pour "ABCD", la table associe A à 3, B à 2, C à 1, et tout autre caractère à 4. À chaque alignement, c'est la lettre du texte située en face de la dernière position du motif qui fixe le saut : plus ce décalage est petit, plus l'algorithme examine d'alignements.

]]> 1.0 0.0 0 true true abc 20 fois la lettre A

]]> Erreur : la table associe A à un décalage de 3. On n'examine que les alignements 0, 3, …, 15, soit 6.

]]> 20 fois la lettre B

]]> Erreur : la table associe B à un décalage de 2. Les alignements 0, 2, …, 16 font 9 alignements, moins qu'avec la lettre C, dont le décalage n'est que de 1.

]]> 20 fois la lettre X

]]> Erreur : X est absent du motif, le décalage vaut donc 4, la longueur du motif. On n'examine que les alignements 0, 4, 8, 12 et 16, soit 5.

]]> 20 fois la lettre C

]]> Bonne réponse : la table associe C à un décalage de 1, le plus petit possible. L'algorithme examine alors toutes les positions de 0 à 16, soit 17 alignements, autant que l'algorithme naïf.

]]> Recherche textuelle — Q24 : Bug subtil Un élève écrit la boucle externe de Boyer-Moore comme
while i < n - m: au lieu de while i <= n - m:.
Quel est l'effet ?

]]> Bug très classique des problèmes de bornes :
< versus <=. Un test sur texte = "abc",
motif = "bc" détecte immédiatement le bug : n - m
vaut 1, donc while i < 1 ne teste que i=0 et rate
le motif en position 1.

]]> 1.0 0.0 0 true true abc L'algorithme rate les motifs situés à la toute fin du texte

]]> Bonne réponse : la position i = n - m est la
dernière où le motif tient encore dans le texte.
La condition i < n - m exclut cette position
et rate les occurrences finales.

]]> L'algorithme est plus rapide (gain négligeable)

]]> Erreur : la performance n'est pas le problème.

]]> L'algorithme renvoie des positions incorrectes

]]> Erreur : les positions trouvées sont correctes,
on en rate juste certaines (celles à la fin).

]]> L'algorithme entre dans une boucle infinie

]]> Erreur : la boucle se termine bien, juste trop
tôt.

]]> Recherche textuelle — Q25 : Comparaison synthétique Parmi les affirmations suivantes sur les algorithmes
de recherche textuelle vus en NSI, laquelle est
fausse ?

]]> « Toujours plus rapide » est presque toujours faux en
algorithmique : chaque algorithme a ses cas
favorables et ses pathologies. Le choix dépend du
profil des données.

]]> 1.0 0.0 0 true true abc Boyer-Moore-Horspool construit sa table à partir du motif seul

]]> Vrai : le prétraitement ne lit que le motif, avant tout parcours du texte. La même table sert donc pour n'importe quel texte.

]]> L'algorithme naïf a une complexité O(n × m) dans le pire cas

]]> Vrai : c'est sa complexité de pire cas standard.

]]> Boyer-Moore-Horspool compare le motif au texte de droite à gauche

]]> Vrai : à chaque alignement, la comparaison commence par le dernier caractère du motif et remonte vers le premier.

]]> Boyer-Moore-Horspool est toujours plus rapide que l'algorithme naïf

]]> Faux (donc bonne réponse) : sur certains textes (alphabet réduit, motif répétitif), les décalages restent très petits et Boyer-Moore examine autant d'alignements que le naïf, avec en plus le travail de consultation de la table.

]]> Recherche textuelle — Q26 : Code de l'algorithme naïf Quelle fonction Python illustre l'algorithme naïf de
recherche textuelle par comparaison caractère par
caractère, en renvoyant la liste des indices de
début de chaque occurrence ?

]]> Cet algorithme illustre clairement le schéma de
double boucle (externe sur les positions, interne
sur la comparaison caractère par caractère).
C'est la base pédagogique avant d'aborder
Boyer-Moore.

]]> 1.0 0.0 0 true true abc `python
def recherche_naif(texte, motif):
positions = []
for i in range(len(texte)):
if texte[i] == motif[0]:
positions.append(i)
return positions
`

]]> Erreur : on ne compare que le premier
caractère du motif, jamais les suivants.
Pour motif = "abra" dans
"abracadabra", ce code renvoie
[0, 3, 5, 7, 10], toutes les positions
de 'a', alors que les occurrences de
"abra" commencent aux indices 0 et 7.

]]> `python
def recherche_naif(texte, motif):
for i in range(len(texte)):
if texte[i] == motif:
return i
return -1
`

]]> Erreur : on compare un seul caractère du texte
avec toute la chaîne motif, ce qui est
toujours faux (sauf si le motif est de
longueur 1). Et on ne renvoie qu'une seule
position au lieu de toutes les occurrences.

]]> `python
def recherche_naif(texte, motif):
positions = []
n, m = len(texte), len(motif)
for i in range(n - m + 1):
j = 0
while j < m and texte[i + j] == motif[j]:
j += 1
if j == m:
positions.append(i)
return positions
`

]]> Bonne réponse : la boucle externe parcourt les
positions valides ; la boucle interne compare
caractère par caractère et s'arrête au premier
échec. Si on a comparé tous les caractères du
motif (j == m), on a trouvé une occurrence.

]]> `python
def recherche_naif(texte, motif):
positions = []
for i in range(len(texte)):
if texte[i:i + len(motif)] == motif:
positions.append(i)
return positions
`

]]> Cette version fonctionne, mais utilise une
comparaison de tranches qui repose sur
l'opération == de Python. Elle masque la
mécanique caractère par caractère qu'on
souhaite illustrer dans l'algorithme naïf
pédagogique. De plus, la boucle va trop loin
(jusqu'à len(texte) - 1), ce qui peut
provoquer des comparaisons inutiles avec des
tranches plus courtes que m.

]]> Recherche textuelle — Q27 : Saut maximal en pratique Avec le motif motif = "exercice" (longueur 8) et
le texte "élève fait son devoir", on aligne le
motif au tout début. Le caractère du texte aligné
avec la fin du motif est 'a' (de « fait »).
Sachant que 'a' n'apparaît pas dans "exercice",
de combien décale-t-on ?

]]> C'est ce mécanisme de saut maximal qui rend
Boyer-Moore sous-linéaire dans le meilleur cas :
pour des textes en alphabet riche (lettres latines,
ponctuation), la plupart des caractères du texte
sont absents du motif, et on saute donc presque
toujours de m positions.

]]> 1.0 0.0 0 true true abc 0 position (on doit tester à nouveau au même endroit)

]]> Erreur : un décalage de 0 ferait boucler
l'algorithme indéfiniment. C'est précisément
pour cela qu'on exclut le dernier caractère
du motif lors du pré-traitement de la table
de décalages.

]]> 8 positions (la longueur du motif)

]]> Bonne réponse : 'a' n'étant pas présent dans
"exercice", on peut sauter de toute la
longueur du motif sans risque de manquer une
occurrence. C'est le saut maximal possible.
Sur du texte courant, ce type de saut est
fréquent et explique la rapidité de
Boyer-Moore.

]]> 1 position

]]> Erreur : c'est ce que ferait l'algorithme naïf
(avancer d'une position après chaque échec).
L'intérêt de Boyer-Moore est précisément de
sauter davantage en s'appuyant sur la table
de décalages.

]]> 4 positions (la moitié de la longueur du motif)

]]> Erreur : Boyer-Moore ne fait pas de demi-saut
arbitraire. La règle est claire : si le
caractère est absent du motif, on saute de
la longueur entière m du motif.

]]> Recherche textuelle — Q28 : Un texte deux fois plus long On cherche le même motif dans un texte deux fois plus long, avec
l'algorithme naïf. Comment évolue le temps de recherche, dans le
pire cas ?

]]> Le coût du naïf est en O(n × m) : linéaire en chacune des
deux longueurs.

]]> 1.0 0.0 0 true true abc Il est divisé par deux, les occurrences étant plus faciles à trouver

]]> Erreur : un texte plus long ne rend rien plus facile.

]]> Il quadruple, le coût étant proportionnel au carré de la longueur

]]> Erreur : le facteur m est la longueur du motif, qui n'a pas
changé.

]]> Il ne change pas, seule la longueur du motif comptant

]]> Erreur : chaque position du texte est un alignement à tester.

]]> Il double environ, le coût étant proportionnel à la longueur du texte

]]> Bonne réponse : le pire cas coûte de l'ordre de n × m
comparaisons ; à motif fixé, le coût est linéaire en n.

]]> Recherche textuelle — Q29 : Le meilleur cas de Boyer-Moore Un texte de 1000 caractères, un motif de 10 caractères. Dans
le meilleur cas, à chaque alignement, le dernier caractère comparé
est absent du motif et l'algorithme de Boyer-Moore saute de 10
positions. Combien de comparaisons fait-il environ ?

]]> Boyer-Moore peut faire moins de comparaisons que le texte n'a de
caractères : un motif long sur un alphabet riche donne des sauts
longs.

]]> 1.0 0.0 0 true true abc 100, une par saut de 10

]]> Bonne réponse : une seule comparaison par alignement, et
1000 / 10 = 100 alignements. Le texte est lu en sautant la
plupart de ses caractères.

]]> 10000, le pire cas du naïf

]]> Erreur : n × m est le pire cas de l'algorithme naïf, à
l'opposé de ce meilleur cas.

]]> 1000, une par caractère du texte

]]> Erreur : les caractères sautés ne sont jamais comparés.

]]> 10, une par caractère du motif

]]> Erreur : il faut bien parcourir tout le texte, par sauts.

]]> Recherche textuelle — Q30 : Trouver toutes les occurrences L'algorithme de recherche renvoie la position de la première
occurrence. Que faut-il changer pour obtenir toutes les
occurrences ?

]]> Une recherche de toutes les occurrences renvoie une liste de
positions, éventuellement vide.

]]> 1.0 0.0 0 true true abc Chercher le motif à l'envers pour trouver la dernière occurrence

]]> Erreur : on obtiendrait une occurrence, pas toutes.

]]> Relancer la recherche depuis le début du texte après chaque occurrence

]]> Erreur : on retrouverait toujours la même première occurrence.

]]> Rien, un algorithme de recherche ne peut trouver qu'une occurrence

]]> Erreur : il suffit de ne pas s'arrêter à la première.

]]> Mémoriser chaque position trouvée et continuer le parcours au lieu de renvoyer

]]> Bonne réponse : au lieu d'un return dès la première
occurrence, on ajoute la position à une liste et on poursuit
jusqu'à la fin du texte.

]]> Recherche textuelle — Q31 : Un motif plus long que le texte Le motif cherché est plus long que le texte. Que renvoie une
recherche naïve correctement écrite, et au prix de combien de
comparaisons ?

]]> Les cas limites, motif vide ou motif plus long que le texte, se
testent avant tout : un bon algorithme les traite sans travail.

]]> 1.0 0.0 0 true true abc Une erreur d'exécution, l'indice dépassant la fin du texte

]]> Erreur : une boucle bornée par n - m + 1 ne fait aucun tour
quand cette borne est négative.

]]> Aucune occurrence, sans aucune comparaison de caractères

]]> Bonne réponse : il n'existe aucun alignement possible, la boucle
sur les positions ne fait aucun tour.

]]> Aucune occurrence, après avoir comparé tous les caractères du texte

]]> Erreur : aucune comparaison n'est nécessaire, faute
d'alignement.

]]> Une occurrence à la position 0, le début coïncidant

]]> Erreur : une occurrence exige que tout le motif soit présent.

]]> Recherche textuelle — Q32 : Le pire cas du naïf en chiffres Le texte est formé de 10 lettres a. Le motif est formé de
2 lettres a suivies d'un b. L'algorithme naïf compare de
gauche à droite et s'arrête au premier échec. Combien de
comparaisons fait-il en tout ?

]]> Un texte répétitif et un motif qui n'échoue qu'à la fin font
payer au naïf son coût maximal, proche de n × m.

]]> 1.0 0.0 0 true true abc 30, soit 10 alignements de 3 comparaisons

]]> Erreur : il n'y a que 8 alignements possibles.

]]> 8, une seule par alignement tenté

]]> Erreur : chaque alignement coûte 3 comparaisons, l'échec
n'arrivant qu'au dernier caractère.

]]> 24, soit 8 alignements de 3 comparaisons

]]> Bonne réponse : à chaque alignement, les 2 premiers
caractères coïncident et seul le b final échoue : 3
comparaisons, pour chacun des 8 alignements.

]]> 10, une par caractère du texte

]]> Erreur : chaque alignement relit les mêmes caractères.

]]> Recherche textuelle — Q33 : Les comparaisons d'un seul alignement À un alignement donné, l'algorithme naïf compare le motif abxyz
à la portion de texte abcde, caractère par caractère de gauche à
droite, et s'arrête au premier échec. Combien de comparaisons
fait-il ?

]]> L'arrêt au premier échec est ce qui rend le naïf rapide en
pratique : la plupart des alignements échouent dès les premiers
caractères.

]]> 1.0 0.0 0 true true abc 0, les deux mots étant différents

]]> Erreur : savoir qu'ils diffèrent demande justement des
comparaisons.

]]> 3, jusqu'au premier échec inclus

]]> Bonne réponse : les premiers caractères coïncident, et la
comparaison qui échoue est la 3-ième ; l'alignement est
abandonné aussitôt.

]]> 1, le premier caractère seulement

]]> Erreur : la comparaison continue tant que les caractères
coïncident.

]]> 5, tous les caractères du motif

]]> Erreur : après un échec, inutile de comparer la suite.

]]> Recherche textuelle — Q34 : Le décalage après un échec Dans l'algorithme naïf, de combien de positions décale-t-on le
motif après un alignement qui échoue ?

]]> Le naïf avance toujours d'un cran ; Boyer-Moore gagne en avançant
davantage quand c'est sans risque.

]]> 1.0 0.0 0 true true abc De deux positions, pour aller plus vite

]]> Erreur : sauter une position manquerait des occurrences.

]]> Jusqu'au caractère qui a provoqué l'échec

]]> Erreur : c'est une idée de Boyer-Moore, pas du naïf.

]]> De la longueur du motif, pour ne pas revenir en arrière

]]> Erreur : on manquerait les occurrences qui commencent à
l'intérieur de l'alignement raté.

]]> D'une seule, quel que soit l'endroit de l'échec

]]> Bonne réponse : le naïf ne tire aucune information de l'échec ;
il essaie la position suivante.

]]> Recherche textuelle — Q35 : Boyer-Moore avec un motif d'un seul caractère On cherche un motif réduit à un seul caractère avec l'algorithme
de Boyer-Moore. Comment se comporte-t-il ?

]]> L'avantage de Boyer-Moore grandit avec la longueur du motif ; sur
un motif très court, il se réduit au naïf.

]]> 1.0 0.0 0 true true abc Il échoue aussitôt, la table de décalage étant vide

]]> Erreur : une table vide donne le saut par défaut, 1, et tout
fonctionne.

]]> Il ne compare qu'un caractère du texte sur deux

]]> Erreur : chaque caractère du texte doit être examiné.

]]> Il saute de deux caractères en deux, grâce à sa table

]]> Erreur : un saut de deux manquerait un caractère du texte.

]]> Il examine chaque caractère du texte, comme le naïf

]]> Bonne réponse : le saut maximal vaut la longueur du motif, soit
1 ; chaque alignement coûte une comparaison et avance d'une
position. Aucun gain possible.

]]> Recherche textuelle — Q36 : Chercher un mot entier La recherche du motif art dans partir renvoie une occurrence,
alors que l'on voulait le mot entier. Comment restreindre la
recherche aux mots entiers ?

]]> Les algorithmes de recherche travaillent sur des caractères, pas
sur des mots : la notion de mot entier s'ajoute par un test sur
les voisins.

]]> 1.0 0.0 0 true true abc Utiliser Boyer-Moore, qui ne trouve que des mots entiers

]]> Erreur : Boyer-Moore cherche des sous-chaînes, exactement comme
le naïf.

]]> Vérifier que les caractères voisins de l'occurrence ne sont pas des lettres

]]> Bonne réponse : une occurrence est un mot entier si elle est
bordée, de chaque côté, par un espace, une ponctuation ou le
bord du texte.

]]> Chercher le motif en majuscules, les mots entiers commençant par une majuscule

]]> Erreur : la casse n'a aucun rapport avec les limites de mots.

]]> Ajouter un espace au début du motif seulement

]]> Erreur : cela manquerait les mots en début de texte et
accepterait artiste.

]]>