Va innovatsiyalar vazirligi osiyo xalqaro universitetining ijtimoiy

Python dasturini amalga oshirish
import yozishdan *
# Ushbu versiya katta-kichik harflarga mos kelmasligi uchun ASCII-dagi ingliz alifbosiga sezgir.
# Ushbu xususiyatni o'chirish uchun alphabet_index ord(c) sifatida belgilang va "26" misollarini almashtiring
# "256" yoki siz xohlagan maksimal kod nuqtasi bilan. Unicode uchun siz UTF-8 da mos kelishingiz mumkin
0x10FFFF o'lchamli jadval yaratish o'rniga # bayt.
ALPHABET_SIZE = 26
def alphabet_index(c: str) -> int:
"""Ingliz alifbosida 0 dan boshlab berilgan belgi indeksini qaytaring."""
val = ord(c.lower()) - ord("a")
assert val >= 0 va val < ALPHABET_SIZE
qaytish val
def match_length(S: str, idx1: int, idx2: int) -> int:
"""IDx1 va idx2 dan boshlanadigan S pastki satrlari mosligi uzunligini qaytaring."""
agar idx1 == idx2:
qaytish len(S) - idx1
match_count = 0
esa idx1 < len(S) va idx2 < len(S) va S[idx1] == S[idx2]:
match_count += 1
idx1 += 1
idx2 += 1
return match_count
def fundamental_preprocess(S: str) -> list[int]:
"""Qaytish Z, S ning asosiy qayta ishlanishi.
Z[i] - i dan boshlanadigan pastki qator uzunligi, u ham S ning prefiksi hisoblanadi.
Bu oldindan ishlov berish O(n) vaqtida amalga oshiriladi, bu erda n - S ning uzunligi.
"""
if len(S) == 0: # Bo'sh satrning registrini boshqaradi
qaytish []
if len(S) == 1: # Bir belgili satrning registrini boshqaradi
qaytish [1]
z = [S dagi x uchun 0]
z[0] = len(S)
z[1] = mos_uzunlik(S, 0, 1)
for i in range(2, 1 + z[1]): # 1-5-mashqdan optimallashtirish
z[i] = z[1] - i + 1
# Z-boxning pastki va yuqori chegaralarini belgilaydi
l = 0
r = 0
diapazondagi i uchun (2 + z[1], len(S)):
agar i <= r: # i mavjud z-box ichiga tushsa
k = i - l
b = z[k]
a = r - i + 1
agar b < a: # b mavjud z-box ichida tugasa
z[i] = b
Aks holda: # b z-box oxirida yoki oxirida tugaydi, biz z-boxning o'ng tomonida aniq moslikni bajarishimiz kerak.
z[i] = a + mos_uzunlik(S, a, r + 1)
l = i
r = i + z[i] - 1
Aks holda: # i mavjud z-box ichida turmaydi
z[i] = mos_uzunlik(S, 0, i)
agar z[i] > 0:
l = i
r = i + z[i] - 1
qaytish z
def bad_character_table(S: str) -> list[list[int]]:
"""
S uchun R ni hosil qiladi, bu massivda ba'zi c belgisining o'rni bilan indekslanadi
Ingliz alifbosi. Rdagi bu indeksda har biri uchun aniqlangan |S|+1 uzunlikdagi massiv mavjud
indeksi i S (s dan keyin indeks qo‘shib) c belgisining keyingi joylashuvi
i dan boshlab S ni o‘ngdan chapga kesib o‘tish. Bu doimiy qidiruv uchun ishlatiladi
Boyer-Mur qatorli qidiruv algoritmidagi yomon belgilar qoidasi uchun, garchi u mavjud bo'lsa ham
doimiy bo'lmagan vaqtli echimlarga qaraganda ancha katta hajm.
"""
agar len(S) == 0:
(ALPHABET_SIZE)] oralig'i uchun [[] ni qaytaring
R = [[-1] diapazondagi (ALPHABET_SIZE)]
alfa = [-1 diapazon uchun (ALPHABET_SIZE)]
i, c uchun sanab(S):
alfa[alfavit_indeks(c)] = i
j uchun, raqamlashda (alfa):
R[j].ilova(a)
qaytish R
def good_suffix_table(S: str) -> list[int]:
"""
S uchun L ni hosil qiladi, bu massiv kuchli yaxshi qo'shimcha qoidasini amalga oshirishda foydalaniladi.
L[i] = k, S ning eng katta pozitsiyasi, S[i:] (i dan boshlanadigan S qo'shimchasi) mos keladi
S[:k] ning qo'shimchasi (k bilan tugaydigan S harfidagi pastki qator). Boyer-Murda foydalanilganda, L miqdorini beradi
P ni T ga nisbatan shunday siljitingki, T da P ning hech bir misoli va P[:L[i]] qo‘shimchasi o‘tkazib yuborilmaydi.
oldingi moslashish urinishida P qo'shimchasi bilan moslangan T pastki qatoriga mos keladi.
Xususan, agar mos kelmaslik Pdagi i-1 pozitsiyasida sodir bo'lsa, siljish kattaligi berilgan
len(P) - L[i] tenglamasi bo'yicha. L[i] = -1 bo'lsa, to'liq siljish jadvali ishlatiladi.
Faqat to'g'ri qo'shimchalar muhim bo'lgani uchun L[0] = -1.
"""
L = [S dagi c uchun -1]
N = fundamental_preprocess(S[::-1]) # S[::-1] teskari S
N.teskari()
j uchun diapazonda(0, len(S) - 1):
i = len(S) - N[j]
agar i != len(S):
L[i] = j
Qaytish L
def full_shift_table(S: str) -> list[int]:
"""
S uchun F ni hosil qiladi, bu massiv Boyer-Murdagi yaxshi qo'shimcha qoidasining maxsus holatida ishlatiladi.
string qidiruv algoritmi. F[i] - S[i:] ning eng uzun qo'shimchasining uzunligi, bu ham a
S prefiksi. U qo'llaniladigan hollarda, P ga nisbatan naqshning siljishi kattaligi
T matni len(P) - F[i] i-1 da yuzaga kelgan nomuvofiqlik uchun.
"""
F = [S dagi c uchun 0]
Z = fundamental_preprocess(S)
eng uzun = 0
i uchun, sanab o'tishda zv (teskari (Z)):
eng uzun = max(zv, eng uzun) agar zv == i + 1 boshqa eng uzun
F[-i - 1] = eng uzun
qaytish F
def string_search(P, T) -> list[int]:
"""
Boyer-Mur qatorli qidiruv algoritmini amalga oshirish. Bu P ning barcha hodisalarini topadi
Tda va optimalni aniqlash uchun naqshni oldindan qayta ishlashning ko'plab usullarini o'z ichiga oladi
satrni siljitish va taqqoslashni o'tkazib yuborish uchun miqdor. Amalda u O(m) da ishlaydi (va hatto
subchiziqli) vaqt, bu erda m - T ning uzunligi. Bu amalga oshirish katta-kichik harflarni sezmaydi
ASCII alifbo belgilari bo'yicha qidirish, bo'shliqlar kiritilmagan.
"""
agar len(P) == 0 yoki len(T) == 0 yoki len(T) < len(P):
qaytish []
mos keladi = []
# Oldindan ishlov berish
R = yomon_belgi_jadval(P)
L = yaxshi_qo'shimcha_jadval(P)
F = to'liq_shift_jadval(P)
k = len(P) - 1 # P uchining T ga nisbatan tekislanishini ifodalaydi
oldingi_k = -1 # Oldingi bosqichdagi tekislashni ifodalaydi (Galil qoidasi)
esa k
i = len(P) - 1 # Pda solishtirish uchun belgi
h = k # Tda solishtirish uchun belgi
i >= 0 va h > oldingi_k va P[i] == T[h]: # P oxiridan boshlanadigan mosliklar
i -= 1
h -= 1
agar i == -1 yoki h == oldingi_k: # Moslik topilgan (Galil qoidasi)
matches.append(k - len(P) + 1)
k += len(P) - F[1] agar len(P) > 1 boshqa 1 bo‘lsa
else: # Moslik yo'q, yomon belgi va yaxshi qo'shimchalar qoidalarining maksimal soniga siljiting
char_shift = i - R[alfavit_indeksi(T[h])][i]
agar i + 1 == len(P): # Birinchi urinishda nomuvofiqlik yuz berdi
suffix_shift = 1
elif L[i + 1] == -1: # Mos keladigan qo'shimcha P ning hech bir joyida ko'rinmaydi.
suffix_shift = len(P) - F[i + 1]
else: # Mos keladigan qo'shimcha P da paydo bo'ladi
suffix_shift = len(P) - 1 - L[i + 1]
shift = maksimal (char_shift, suffix_shift)
oldingi_k = k agar shift >= i + 1 boshqa oldingi_k # Galil qoidasi
k += siljish
javob o'yinlari
Xulosa
Boyer Mur algoritmi kabi algoritmlarni tushunish va amalga oshirish dasturiy ta'minotni ishlab chiqish uchun juda muhimdir. Ushbu algoritmni JavaScript-da qanday amalga oshirishni bilish ilovalaringizni optimallashtirishga va kodingizni yanada samaraliroq qilishga yordam beradi.
Boyer-Mur algoritmi qatorlarni qidirishning samarali algoritmidir, ayniqsa katta manba matnlari bilan ishlashda samarali. U matn qismlarini o'tkazib yuborish uchun dastlabki ishlov berish bosqichida to'plangan ma'lumotlardan foydalanib, qidiruv naqshining oxiridagi elementlarni matnga solishtirish orqali ishlaydi. Bu boshqa qidiruv algoritmlariga qaraganda kamroq vaqt murakkabligiga olib keladi, bu esa string qidiruv operatsiyalarini optimallashtirish uchun juda foydali bo'ladi.
nomuvofiqlikka duch kelganda asosiy qidiruv funktsiyasida qancha pozitsiyani o'tkazib yuborish mumkinligini aniqlash uchun ishlatiladi.