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

]]> Compter le nombre de caractères dans un texte

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

]]> Trier un texte par ordre alphabétique

]]> Erreur : aucun rapport avec le tri.

]]> Trouver toutes les positions d'un motif (chaîne courte) dans un texte (chaîne longue)

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

]]> 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 utilise une table de hachage pour aller plus vite

]]> Erreur : c'est l'idée de l'algorithme de
Rabin-Karp, pas du naïf.

]]> On teste chaque position de départ possible et on compare le motif 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 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.

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

]]> n - m - 1

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

]]> n

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

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

]]> 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(n + m)

]]> Erreur : cette complexité correspond à
l'algorithme de Knuth-Morris-Pratt, et non à
la version naïve.

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

]]> Erreur : aucune dichotomie dans cet algorithme.

]]> O(n)

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

]]> 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 mémoïsation

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

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

]]> Comparer le motif de droite à gauche et sauter plusieurs positions en cas d'échec grâce à 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.

]]> 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
plus avancées (Aho-Corasick pour plusieurs motifs, par
exemple).

]]> 1.0 0.0 0 true true abc La commande Unix grep

]]> C'est exact, mais ce n'est pas la seule bonne
réponse.

]]> Toutes les réponses précédentes

]]> Bonne réponse : Ctrl+F, grep et la bio-informatique
sont trois applications classiques. La recherche
textuelle est partout.

]]> La fonction Ctrl+F d'un éditeur de texte

]]> C'est exact, mais ce n'est pas la seule bonne
réponse. Lis bien toutes les propositions.

]]> L'analyse de séquences ADN

]]> C'est exact, mais ce n'est pas la seule bonne
réponse.

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

]]> Le texte modifié pour retirer le motif

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

]]> La longueur du motif

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

]]> 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 [0, 2]

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

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

]]> []

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

]]> [1, 2, 3]

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

]]> 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 = 'hello', motif = 'hello'

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

]]> 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 = '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 = '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 premier (gauche)

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

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

]]> Un caractère choisi au hasard

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

]]> Le caractère du milieu

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

]]> 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': 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': 0, 'a': 1, 'b': 2}

]]> Erreur : c'est l'inverse, et il ne faut pas
inclure 'b'.

]]> {'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 (la longueur du motif)

]]> 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': 0, 'a': 3}

]]> Erreur : 'm' apparaît aussi en position 0, on
ne garde que la position la plus à droite
(hors dernière position).

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

]]> Erreur : 'm' final est exclu mais celui de
position 2 donne 5 - 1 - 2 = 2, pas 4.

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

]]> Bonne réponse : 'm' en position 2 (la plus à
droite hors fin), décalage 5 - 1 - 2 = 2 ;
'a' en position 3, décalage 5 - 1 - 3 = 1.

]]> {'m': 2, 'a': 3, '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'il donnerait un décalage de 0, ce qui 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 de la mémoire

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

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

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

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

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

]]> 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 11 (la longueur du texte)

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

]]> 2

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

]]> 1

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

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

]]> Recherche textuelle — Q16 : Complexité dans le pire cas Quelle est la complexité de Boyer-Moore-Horspool dans
le pire cas ?

]]> Point important : l'algorithme de
Boyer-Moore-Horspool n'apporte aucune garantie
de complexité dans le pire cas. C'est en moyenne
et au meilleur cas qu'il se distingue.
L'algorithme de Knuth-Morris-Pratt, en revanche,
garantit une complexité en $O(n + m)$, mais avec
un prétraitement plus coûteux.

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

]]> Erreur : O(n) est atteignable mais pas garanti
dans le pire cas (la version Horspool n'a pas
cette garantie).

]]> O(log n)

]]> Erreur : aucune dichotomie.

]]> O(n × m)

]]> Bonne réponse : dans le pire cas (par exemple,
motif "aaab" dans "aaaa...a"), la complexité
rejoint celle du naïf. La force de Boyer-Moore
est dans le cas moyen et le meilleur cas.

]]> O(n + m)

]]> Erreur : cette complexité correspond à
l'algorithme de Knuth-Morris-Pratt, et non à
celui de Boyer-Moore-Horspool.

]]> Recherche textuelle — Q17 : Meilleur cas sous-linéaire Quelle est la complexité dans le meilleur cas de
Boyer-Moore-Horspool ?

]]> Cette propriété sous-linéaire est ce qui rend
Boyer-Moore particulièrement performant pour les
motifs longs avec un alphabet varié.

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

]]> Bonne réponse : si à chaque échec on saute de m
positions, on n'effectue qu'environ n/m
comparaisons. C'est sous-linéaire : on trouve
le motif sans examiner chaque caractère du texte.

]]> O(n)

]]> Erreur : on fait mieux que linéaire dans le
meilleur cas. Boyer-Moore peut être sous-linéaire.

]]> O(m)

]]> Erreur : il faut au minimum traverser le texte
(modulo les sauts), donc cela dépend de n.

]]> O(1)

]]> Erreur : on a toujours besoin de plusieurs
comparaisons.

]]> 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 l'alphabet est large

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

]]> Quand le texte et le motif ne contiennent presque que des caractères identiques (par exemple uniquement des 'a')

]]> Bonne réponse : avec un alphabet réduit, les
décalages sont presque toujours de 1 et on
retombe sur un parcours position par position.

]]> Quand le motif est très court

]]> Partiellement vrai (les sauts sont limités à m),
mais ce n'est pas le pire cas.

]]> Quand le texte est très long

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

]]> Recherche textuelle — Q19 : Cas particuliers Que doit renvoyer recherche_naif("abc", "") (motif
vide) selon la convention de Python ?

]]> Cas piège classique. Beaucoup d'implémentations
doivent traiter ce cas explicitement (par exemple en
ajoutant if m == 0: return list(range(n + 1))).

]]> 1.0 0.0 0 true true abc []

]]> Discutable, mais la convention Python (str.find,
re.finditer) considère le motif vide comme
présent à toutes les positions.

]]> [0, 1, 2, 3]

]]> Bonne réponse : par convention, le motif vide est
présent à chaque position du texte, y compris à
la fin. Pour un texte de longueur 3, cela donne
n + 1 = 4 positions.

]]> [0]

]]> Erreur : pas seulement à la position 0.

]]> Une erreur (ValueError)

]]> Erreur : Python ne lève pas d'erreur pour le
motif vide.

]]> Recherche textuelle — Q20 : Mécanisme de `grep` La commande Unix grep (et ses variantes egrep,
fgrep) utilise principalement quel type d'algorithme
pour la recherche de motifs simples ?

]]> grep est un excellent exemple d'application directe
des algorithmes étudiés en NSI. Sa rapidité tient à
l'utilisation conjointe de Boyer-Moore et d'automates
compilés.

]]> 1.0 0.0 0 true true abc Algorithme naïf O(n × m)

]]> Erreur : grep est très optimisé. Le naïf est
trop lent pour des fichiers volumineux.

]]> Programmation dynamique

]]> Erreur : la programmation dynamique sert pour
d'autres problèmes (alignement de séquences,
distance d'édition).

]]> Recherche dichotomique sur le texte

]]> Erreur : impossible sans pré-trier le texte.

]]> Variantes de Boyer-Moore (avec fgrep ou les motifs sans expression régulière)

]]> Bonne réponse : fgrep (ou grep -F) utilise
des variantes de Boyer-Moore pour les motifs
fixes. Pour les expressions régulières, grep
utilise des automates finis (DFA/NFA).

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

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

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

]]> 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': 1, 'b': 2, 'r': 3, 'c': 4, 'd': 5}

]]> Erreur : valeurs incorrectes. Il faut prendre la
dernière position (hors fin) de chaque
caractère.

]]> {'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': 1, 'r': 2, 'c': 3, 'd': 4}

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

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

]]> Erreur : le 'a' final est exclu ; on n'a
qu'une seule entrée pour 'a' (la position 7).

]]> Recherche textuelle — Q23 : Choix d'algorithme On veut chercher un motif de longueur 100 dans un
texte ADN (alphabet {A, C, G, T}) de 10⁹
nucléotides. Quel algorithme est le plus pertinent ?

]]> Le programme de NSI s'arrête à Boyer-Moore-Horspool,
mais en bio-informatique réelle, on utilise des
structures de données plus avancées (arbres de
suffixes, FM-index) pour gérer des génomes entiers.

]]> 1.0 0.0 0 true true abc Un algorithme spécialisé (Knuth-Morris-Pratt, Aho-Corasick, ou une indexation par transformée de Burrows-Wheeler) garantissant une complexité en $O(n + m)$

]]> Pour des séquences ADN volumineuses, on
utilise l'algorithme de Knuth-Morris-Pratt,
celui d'Aho-Corasick (pour plusieurs motifs
recherchés simultanément), ou des
indexations précalculées (les outils BWA et
Bowtie reposent sur la transformée de
Burrows-Wheeler).

]]> Algorithme naïf, suffisant pour la plupart des cas

]]> Erreur : avec n = 10⁹ et m = 100, le pire cas
serait 10¹¹ comparaisons. Trop lent.

]]> Recherche dichotomique

]]> Erreur : impossible sans tri du texte (ce qui
détruirait la séquence).

]]> Boyer-Moore-Horspool, simple à implémenter mais limité par l'alphabet réduit

]]> C'est mieux que le naïf mais l'alphabet à 4
symboles limite les sauts. Il existe mieux.

]]> 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 entre dans une boucle infinie

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

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

]]> 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 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 peut atteindre O(n / m) dans le meilleur cas

]]> Vrai : c'est sa propriété sous-linéaire
remarquable.

]]> Pour de nombreux motifs simultanés, on préfère Aho-Corasick à Boyer-Moore

]]> Vrai : Aho-Corasick traite plusieurs motifs en
un seul passage du texte (utilisé par les
antivirus, par exemple).

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

]]> Faux (donc bonne réponse) : sur certains
textes-pathologiques (alphabet réduit, motif
répétitif), Boyer-Moore retombe au pire cas du
naïf, voire est plus lent à cause de la
gestion des décalages.

]]> Recherche textuelle — Q26 : Code de l'algorithme naïf Quelle fonction Python implémente correctement
l'algorithme naïf de recherche textuelle, 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 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.

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

]]> def recherche_naif(texte, motif): return [i for i, c in enumerate(texte) if c == motif[0]]]]> Erreur : on ne vérifie que le premier
caractère, pas le motif complet. Pour
motif = "abc" dans "abracadabra", on
renverrait toutes les positions de 'a',
y compris celles où "abc" n'est pas le
début.

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

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

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

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

]]>