Lengste vanlige substring python

Problemet er å finne den lengste vanlige substring i en gitt streng. Oppgaven er å ta to strenger og finne den lengste vanlige substringen med eller uten å gjenta tegn. Med andre ord, samsvar med den lengste vanlige substringen gitt i samme rekkefølge og til stede i begge strengene. For eksempel er 'Tech' en sekvens av tegn gitt i 'NextTech', som også er Substring.

Prosessen for å finne den lengste vanlige etterfølgende:

Den enkle prosessen for å finne den lengste vanlige etterfølgelsen er å sjekke hvert tegn på streng 1 og finne den samme sekvensen i streng 2 ved å sjekke hvert tegn på streng 2 en etter en for å se om noen substring er vanlig i begge strengene. La oss for eksempel si at vi har en streng 1 'ST1' og String 2 'ST2' med henholdsvis lengde A og B. Kontroller alle underlagene til 'ST1' og begynn å iterere gjennom 'ST2' for å sjekke om det er noen substring av 'ST1' som eksisterer som 'ST2'. Begynn med å matche substring av lengde 2 og øke lengden med 1 i hver iterasjon, stiger til maksimal lengde på strengene.

Eksempel 1:

Dette eksemplet handler om å finne den lengste vanlige substringen med gjentatte tegn. Python gir enkle innebygde metoder for å utføre noen funksjoner. I eksemplet nedenfor har vi gitt den enkleste måten å finne den lengste vanlige etterfølgende i 2 strenger. Å kombinere 'for' og 'mens' løkker brukes til å få den lengste vanlige substring i en streng. Ta en titt på eksemplet gitt nedenfor:

Def Longcomsubs (ST1, ST2):
Ans = 0;
for en i rekkevidde (len (ST1)):
For B i rekkevidde (Len (ST2)):
k = 0;
mens ((a + k) < len(st1) and (b + k) < len(st2)
og ST1 [a + k] == st2 [b + k]):
k = k + 1;
Ans = maks (Ans, K);
Returner Ans;
if __name__ == '__main__':
A = 'abbaab'
B = 'babaab'
i = len (a)
j = len (b)
trykk ('Den lengste vanlige substring i en streng er', LongcomSubs (A, B))

Følgende utdata vil bli produsert etter å ha utført koden ovenfor. Det vil finne den lengste vanlige substringen og gi deg som produksjon.

Eksempel 2:

En annen måte å finne den lengste vanlige substring er å følge den iterative tilnærmingen. En 'for' sløyfe brukes til iterasjon, og en 'hvis' tilstand samsvarer med den vanlige substring.

def longcomsubs (a, b, m, n):
Maxlen = 0
EndIndex = m
Finn = [[0 for x i rekkevidde (n + 1)] for y i rekkevidde (m + 1)]
for i i rekkevidde (1, m + 1):
for j i rekkevidde (1, n + 1):
Hvis a [i - 1] == b [j - 1]:
Finn [i] [j] = finn [i - 1] [j - 1] + 1
Hvis finn [i] [j]> Maxlen:
maxlen = finn [i] [j]
EndIndex = i
Return x [EndIndex - Maxlen: EndIndex]
if __name__ == '__main__':
A = 'abbaab'
B = 'babaab'
i = len (a)
j = len (b)
trykk ('Den lengste vanlige substring i en streng er', LongcomSubs (A, B, I, J))

Utfør koden ovenfor i en hvilken som helst Python -tolk for å få ønsket output. Imidlertid har vi brukt Spyder -verktøyet for å utføre programmet for å finne den lengste vanlige substringen i en streng. Her er utdataene fra ovennevnte kode:

Eksempel 3:

Her er et annet eksempel for å hjelpe deg med å finne den lengste vanlige substringen i en streng ved hjelp av Python -koding. Denne metoden er den minste, enkleste og enkleste måten å finne den lengste vanlige etterfølgelsen. Ta en titt på eksempelkoden gitt nedenfor:

def Common (ST1, ST2):
def _iter ():
for a, b i glidelås (ST1, ST2):
Hvis a == B:
gi a
ellers:
komme tilbake
komme tilbake ".Bli med (_iter ())
if __name__ == '__main__':
A = 'abbaab'
B = 'babaab'
trykk ('Den lengste vanlige substring i en streng er', LongcomSubs (A, B))

Nedenfor kan du finne utdataene fra koden gitt ovenfor

Ved hjelp av denne metoden har vi ikke returnert den vanlige substringen, men lengden på den vanlige substringen. For å hjelpe deg med å få ønsket resultat, har vi vist både utganger og metoder for å få disse resultatene.

Tidskompleksiteten og romkompleksiteten for å finne den lengste vanlige substring

Det er noen kostnader å betale for å utføre eller utføre enhver funksjon; Tidskompleksitet er en av disse kostnadene. Tidskompleksiteten til enhver funksjon beregnes ved å analysere hvor mye tid en uttalelse kan ta for å utføre. For å finne alle underlagene i 'ST1', trenger vi O (A^2), der 'A' er lengden på 'ST1' og 'O' er symbolet på tidskompleksitet. Imidlertid er tidskompleksiteten til iterasjonen og å finne om substringen eksisterer i 'ST2' eller ikke er o (m), hvor 'm' er lengden på 'ST2'. Så den totale tidskompleksiteten ved å oppdage den lengste vanlige substring i to strenger er O (A^2*m). Dessuten er romkompleksiteten en annen kostnad for å utføre et program. Romkompleksiteten representerer rommet et program eller en funksjon vil holde i minnet under utførelse. Derfor er romkompleksiteten ved å finne den lengste vanlige etterfølgelsen O (1), da den ikke krever noe rom for å utføre.

Konklusjon:

I denne artikkelen har vi lært om metodene for å finne den lengste vanlige substringen i en streng ved hjelp av Python -programmering. Vi har gitt tre enkle og enkle eksempler for å få den lengste vanlige substringen i Python. Det første eksemplet bruker kombinasjonen av 'for' og 'mens loop. Mens vi er i det andre eksemplet, har vi fulgt den iterative tilnærmingen ved å bruke 'for' loop og 'hvis' logikk. Tvert imot, i det tredje eksemplet, brukte vi ganske enkelt Python innebygde funksjon for å få lengden på den vanlige substringen i en streng. I kontrast er tidskompleksiteten ved å finne den lengste vanlige substringen i en streng ved bruk av python O (a^2*m), hvor a og ma er lengden på de to strengene; streng 1 og streng 2, henholdsvis.