1 usuario conectado

  Solución al Ejercicio: Encontrar subcadenas comunes

📋 Copiar código

def encontrar_substrings_comunes(cadena1, cadena2):
  """
  Encuentra todos los substrings comunes entre dos cadenas.

  Args:
    cadena1: La primera cadena.
    cadena2: La segunda cadena.

  Returns:
    Una lista de todos los substrings que son comunes a ambas cadenas.
  """
  substrings_comunes = []
  len1 = len(cadena1)
  len2 = len(cadena2)

  for i in range(len1):
    for j in range(i + 1, len1 + 1):
      substring = cadena1[i:j]
      if substring in cadena2 and substring not in substrings_comunes:
        substrings_comunes.append(substring)

  return substrings_comunes

# Ejemplo de uso
cadena_a = "banana"
cadena_b = "bandana"
comunes = encontrar_substrings_comunes(cadena_a, cadena_b)
print(f"Substrings comunes entre '{cadena_a}' y '{cadena_b}': {comunes}")

cadena_c = "programacion"
cadena_d = "logaritmo"
comunes_2 = encontrar_substrings_comunes(cadena_c, cadena_d)
print(f"Substrings comunes entre '{cadena_c}' y '{cadena_d}': {comunes_2}")

 

Explicación del Código:

1. Definición de la función encontrar_substrings_comunes(cadena1, cadena2):

   • Se define una función llamada encontrar_substrings_comunes que acepta dos argumentos: cadena1 y cadena2, que son las dos cadenas entre las cuales se buscarán los substrings comunes.

2. Inicialización de la lista substrings_comunes:

   • Se crea una lista vacía llamada substrings_comunes. Esta lista se utilizará para almacenar todos los substrings que se encuentren en ambas cadenas, evitando duplicados.

3. Obtención de las longitudes de las cadenas:

   • len1 = len(cadena1) y len2 = len(cadena2) almacenan las longitudes de las dos cadenas de entrada. Estas longitudes se utilizan para controlar los límites de los bucles.

4. Generación de substrings de la primera cadena:

   • El primer bucle for i in range(len1): itera a través de cada índice i de la cadena1, que representa el inicio potencial de un substring.
   • El segundo bucle anidado for j in range(i + 1, len1 + 1): itera desde el índice siguiente a i hasta el final de cadena1. El índice j representa el final (no inclusivo) potencial de un substring. Esto asegura que se consideren substrings de todas las longitudes posibles (al menos longitud 1).
   • substring = cadena1[i:j] extrae el substring de cadena1 que comienza en el índice i y termina en el índice j.

5. Verificación de la presencia del substring en la segunda cadena y de duplicados:

   • if substring in cadena2 and substring not in substrings_comunes::
     • substring in cadena2 verifica si el substring extraído de cadena1 existe como una secuencia contigua de caracteres dentro de cadena2.
     • substring not in substrings_comunes verifica si el substring ya ha sido añadido a la lista de substrings comunes. Esto evita que se incluyan duplicados en el resultado final, incluso si un mismo substring aparece varias veces en ambas cadenas.

6. Adición del substring común a la lista:

   • Si ambas condiciones del if son verdaderas (el substring está en cadena2 y no es un duplicado), entonces substrings_comunes.append(substring) añade el substring a la lista substrings_comunes.

7. Retorno de la lista de substrings comunes:

   • Finalmente, después de haber considerado todos los posibles substrings de cadena1, la función devuelve la lista substrings_comunes, que contiene todos los substrings únicos que se encontraron tanto en cadena1 como en cadena2.

8. Ejemplos de uso:

   • Se proporcionan dos ejemplos para ilustrar cómo utilizar la función con diferentes pares de cadenas y se imprime la lista de substrings comunes encontrada en cada caso.