Python de sustring común más largo
El proceso para encontrar la posterior subsecuencia común más larga:
El proceso simple para encontrar la posterior subsecuencia común más larga es verificar cada carácter de la cadena 1 y encontrar la misma secuencia en la cadena 2 verificando cada carácter de la cadena 2 uno por uno para ver si alguna subcadena es común en ambas cuerdas. Por ejemplo, supongamos que tenemos una cadena 1 'st1' y cadena 2 'st2' con longitudes a y b, respectivamente. Verifique todas las subcadenas de 'ST1' y comience a iterando a través de 'ST2' para verificar si existe alguna subcadena de 'ST1' como 'ST2'. Comience con coincidir la subcadena de la longitud 2 y aumentando la longitud en 1 en cada iteración, aumentando a la longitud máxima de las cuerdas.
Ejemplo 1:
Este ejemplo se trata de encontrar la subcadena común más larga con caracteres repetidos. Python proporciona métodos integrados simples para realizar cualquier función. En el siguiente ejemplo, hemos proporcionado la forma más sencilla de encontrar la posterior subsecuencia más larga en 2 cuerdas. La combinación de los bucles 'para' y 'while' se utiliza para obtener la subcadena común más larga en una cadena. Eche un vistazo al ejemplo que se da a continuación:
Def Longcomsubs (ST1, ST2):Ans = 0;
para un rango (len (ST1)):
para B en el rango (LEN (ST2)):
k = 0;
mientras ((a + k) < len(st1) and (b + k) < len(st2)
y st1 [a + k] == st2 [b + k]):
k = k + 1;
Ans = max (ans, k);
devolver la respuesta;
Si __name__ == '__main__':
A = 'abbaab'
B = 'Babaab'
i = len (a)
j = len (b)
Imprimir ('La subcadena común más larga en una cadena es', LongComSubs (a, b))
La siguiente salida se producirá después de ejecutar el código anterior. Encontrará la subcadena común más larga y le dará como salida.
Ejemplo 2:
Otra forma de encontrar la subcadena común más larga es seguir el enfoque iterativo. Se usa un bucle 'para' para la iteración, y una condición 'si' coincide con la subcadena común.
Def Longcomsubs (A, B, M, N):Maxlen = 0
endIndex = m
Encontrar = [[0 para x en rango (n + 1)] para y en el rango (m + 1)]
para i en el rango (1, m + 1):
para j en rango (1, n + 1):
Si a [i - 1] == b [j - 1]:
Encontrar [i] [j] = buscar [i - 1] [j - 1] + 1
Si busca [i] [j]> maxlen:
maxlen = encontrar [i] [j]
endIndex = i
return x [EndIndex - MaxLen: EndIndex]
Si __name__ == '__main__':
A = 'abbaab'
B = 'Babaab'
i = len (a)
j = len (b)
Imprimir ('La subcadena común más larga en una cadena es', LongComsubs (A, B, I, J)))
Ejecute el código anterior en cualquier intérprete de Python para obtener la salida deseada. Sin embargo, hemos utilizado la herramienta Spyder para ejecutar el programa para encontrar la subcadena común más larga en una cadena. Aquí está la salida del código anterior:
Ejemplo 3:
Aquí hay otro ejemplo para ayudarlo a encontrar la subcadena común más larga en una cadena utilizando la codificación de Python. Este método es la forma más pequeña, más simple y fácil de encontrar la posterior subsecuencia más larga. Eche un vistazo al código de ejemplo que se proporciona a continuación:
Def Common (ST1, ST2):def _iter ()::
Para A, B en Zip (ST1, ST2):
Si a == b:
producir un
demás:
devolver
devolver ".unir (_iter ())
Si __name__ == '__main__':
A = 'abbaab'
B = 'Babaab'
Imprimir ('La subcadena común más larga en una cadena es', LongComSubs (a, b))
A continuación puede encontrar la salida del código dado anteriormente
Usando este método, no hemos devuelto la subcadena común sino la longitud de esa subcadena común. Para ayudarlo a obtener el resultado deseado, hemos mostrado salidas y métodos para obtener esos resultados.
La complejidad del tiempo y la complejidad del espacio para encontrar la subcadena común más larga
Hay algún costo de pagar para realizar o ejecutar cualquier función; La complejidad del tiempo es uno de esos costos. La complejidad del tiempo de cualquier función se calcula analizando cuánto tiempo puede tomar una declaración para ejecutar. Por lo tanto, para encontrar todas las subcadenas en 'ST1', necesitamos o (a^2), donde 'a' es la longitud de 'st1' y 'o' es el símbolo de la complejidad del tiempo. Sin embargo, la complejidad del tiempo de la iteración y encontrar si la subcadena existe en 'ST2' o no es O (M), donde 'M' es la longitud de 'ST2'. Por lo tanto, la complejidad del tiempo total de descubrir la subcadena común más larga en dos cadenas es O (a^2*m). Además, la complejidad del espacio es otro costo de ejecutar un programa. La complejidad del espacio representa el espacio que un programa o una función se mantendrá en la memoria durante la ejecución. Por lo tanto, la complejidad espacial de encontrar la posterior subsecuencia común más larga es o (1), ya que no requiere ningún espacio para ejecutar.
Conclusión:
En este artículo, hemos aprendido sobre los métodos para encontrar la subcadena común más larga en una cadena utilizando la programación de Python. Hemos proporcionado tres ejemplos simples y fáciles para obtener la subcadena común más larga en Python. El primer ejemplo usa la combinación de 'for' y 'mientras bucle. Mientras que en el segundo ejemplo, hemos seguido el enfoque iterativo utilizando la lógica 'for' bucle e 'if'. Por el contrario, en el tercer ejemplo, simplemente utilizamos la función incorporada de Python para obtener la longitud de la subcadena común en una cadena. En contraste, la complejidad del tiempo para encontrar la subcadena común más larga en una cadena usando Python es O (A^2*m), donde A y Ma son la longitud de las dos cuerdas; String 1 y String 2, respectivamente.