¿Cómo encontrar dos listas con la misma estructura en python?

Question

Define un procedimiento, same_structure, que toma dos entradas. Debe mostrar True si las listas tienen la misma estructura, y False de lo contrario. Dos valores, p y q tienen la misma estructura si:

Neither p or q is a list. 

Both p and q are lists, they have the same number of elements, and each 
element of p has the same structure as the corresponding element of q. 

EDIT: Para hacer que la imagen clara los siguientes son los resultados esperados

same_structure([1, 0, 1], [2, 1, 2]) 
    ---> True 
same_structure([1, [0], 1], [2, 5, 3]) 
    ---> False 
same_structure([1, [2, [3, [4, 5]]]], ['a', ['b', ['c', ['d', 'e']]]]) 
    ---> True 
same_structure([1, [2, [3, [4, 5]]]], ['a', ['b', ['c', ['de']]]]) 
    ---> False 

pensé recursividad sería mejor para solucionar este problema en Python he encontrado el siguiente código pero no funciona.

def is_list(p): 
    return isinstance(p, list) 

def same_structure(a,b): 
    if not is_list(a) and not is_list(b): 
     return True 
    elif is_list(a) and is_list(b): 
     if len(a) == len(b): 
      same_structure(a[1:],b[1:]) 
    else: 
     return False 

Answer 1

recursividad sería una buena idea, pero no la forma en que has sugerido. En primer lugar (y esto puede ser sólo un error tipográfico), que en realidad no vuelva cualquier cosa aquí:

if len(a) == len(b): 
    same_structure(a[1:],b[1:]) 

En segundo lugar, usted debe tratar de forma recursiva con cada elemento, no cada sublista. es decir .:

if len(a) == len(b): 
    for i in range(len(a)): 
     if not same_structure(a[i], b[i]): 
      return False 
    return True 
else: 
    return False 

Espero que esto ayude.

Answer 2

Falta un caso y olvida volver en el segundo caso. Observe que no es necesario comparar explícitamente las longitudes de las listas, ya que el primer caso se ocupa de esto: si una de las listas está vacía y la otra no, es porque una lista tenía menos elementos que la otra:

def same_structure(a, b): 
    if a == [] or b == []: # one of the lists is empty 
     return a == b  # are both of the lists empty? 
    elif is_list(a[0]) != is_list(b[0]): 
     return False  # one of the elements is a list and the other is not 
    elif not is_list(a[0]): # neither element is a list 
     return same_structure(a[1:], b[1:]) 
    else:     # both elements are lists 
     return same_structure(a[0], b[0]) and same_structure(a[1:], b[1:]) 

Answer 3

en lugar de same_structure(a[1:],b[1:]), es necesario comprobar par de elementos de a y B uno por uno

def is_list(p): 
    return isinstance(p, list) 

def same_structure(a, b): 
    if not is_list(a) and not is_list(b): 
     return True 
    elif (is_list(a) and is_list(b)) and (len(a) == len(b)): 
     return all(map(same_structure, a, b)) # Here 
    return False 

Answer 4

Dado que la especificación dice que la entrada son dos listas, puede recorrer las listas dentro de su función sin más comprueba, y solo hace llamadas recursivas si encuentra sublistas:

def same_structure(a, b): 
    if len(a) != len(b): 
     return False 
    return all(is_list(x) and is_list(y) and same_structure(x, y) or 
       not is_list(x) and not is_list(y) 
       for x, y in zip(a, b)) 

Answer 5

Usted puede tratar de esta manera también también, comprobar el tipo de ambas listas & longitud de ambas listas y hacer esto de forma recursiva para la sub-listas tanto de la lista.

def same_structure(a,b): 
    return isinstance(a, list) and isinstance(b, list) and len(a) == len(b) 
    and all(same_structure_as(c, d) for c, d in zip(a, b) if isinstance(c, list))