def pokemonConHacks(L1, L2): #C L1.reordenar('torneosGanados') entrenador = L1.obtener_elemento(L1.tamanio() - 1) posPokemones = entrenador['pokebals'] print('') subPokemon = Lista() for pokemon in posPokemones: subPokemon.insertar(L2.obtener_elemento(pokemon), 'level') pokemon = subPokemon.obtener_elemento(subPokemon.tamanio() - 1) print("El pokemon con mas nivel es : ", pokemon['name'], "\nnivel: ", pokemon['level'], "\n")
def barridos_name_species(jedis): #A L2 = Lista() print('\nJedis por nombre: ') for pos in range(0, jedis.tamanio()): jedi = jedis.obtener_elemento(pos) print(jedi['name']) L2.insertar(jedi, 'specie') print("\nJedis por Especie: ") for pos in range(0, L2.tamanio()): jedi = L2.obtener_elemento(pos) print(jedi['specie'])
def contar_mayor_cantidad_de_criaturas_derrotadas_por_un_heroe(arbol): vector_heroes = recompilar_datos_de_un_arbol(arbol, 'Derrotado') ocurrencias = 0 lista_dic_heroes = Lista() for nombre_heroe in vector_heroes: ocurrencias = contar_ocurrencias_de_heroe(arbol, nombre_heroe) lista_dic_heroes.insertar( { 'nombre': nombre_heroe, 'cantidad_Derrotados': ocurrencias }, 'cantidad_Derrotados') return lista_dic_heroes
class Grafo(object): def __init__(self, dirigido=True): self.dirigido = dirigido self.inicio = Lista() def insertar_vertice(self, dato, criterio='info', data=None): # ! agregar otro self.inicio.insertar({'info': dato, 'visitado': False, 'aristas': Lista(), 'data': data}, criterio) def insertar_arista(self, peso, origen, destino, criterio='destino', data=None): # ! agregar otro ver_origen = self.inicio.busqueda(origen, 'info') ver_destino = self.inicio.busqueda(destino, 'info') if(ver_origen != -1 and ver_destino != -1): self.inicio.obtener_elemento(ver_origen)['aristas'].insertar({'peso': peso, 'destino': destino, 'data': data}, criterio) if(not self.dirigido and origen != destino): data_aux = deepcopy(data) if(data): data_aux['relacion'].reverse() self.inicio.obtener_elemento(ver_destino)['aristas'].insertar({'peso': peso, 'destino': origen, 'data': data_aux}, criterio) else: print('los vertices origen o destino no estan en el grafo....', origen, destino) def grafo_vacio(self): return self.inicio.lista_vacia() def tamanio(self): return self.inicio.tamanio() def buscar_vertice(self, clave, criterio='info'): return self.inicio.busqueda(clave, criterio=criterio) def buscar_arista(self, origen, destino, criterio='destino'): ver_origen = self.inicio.busqueda(origen, 'info') if(ver_origen != -1): return self.inicio.obtener_elemento(ver_origen)['aristas'].busqueda(destino, criterio) else: return ver_origen def barrido_vertices(self): self.inicio.barrido() def es_adyacente(self, origen, destino): ver_origen = self.inicio.busqueda(origen, 'info') if(ver_origen != -1): destino = self.buscar_arista(origen, destino) if(destino != -1): return True else: return False else: return False def adyacentes(self, origen): ver_origen = self.inicio.busqueda(origen, 'info') if(ver_origen != -1): self.inicio.obtener_elemento(ver_origen)['aristas'].barrido() def eliminar_vertice(self, clave): aux = self.inicio.eliminar(clave, criterio='info') for posicion in range(self.tamanio()): origen = self.inicio.obtener_elemento(posicion)['info'] self.eliminar_arista(origen, clave) return aux def eliminar_arista(self, origen, destino): ver_origen = self.inicio.busqueda(origen, 'info') if(ver_origen != -1): self.inicio.obtener_elemento(ver_origen)['aristas'].eliminar(destino, 'destino') if(not self.dirigido): ver_destino = self.inicio.busqueda(destino, 'info') if(ver_destino != -1): self.inicio.obtener_elemento(ver_destino)['aristas'].eliminar(origen, 'destino') def barrido_profundidad(self, ver_origen): """Barrido en profundidad del grafo.""" while(ver_origen < self.inicio.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) if(not vertice['visitado']): vertice['visitado'] = True print(vertice['info']) aristas = 0 while(aristas < vertice['aristas'].tamanio()): arista = vertice['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(arista['destino']) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) if(not nuevo_vertice['visitado']): self.barrido_profundidad(pos_vertice) aristas += 1 ver_origen += 1 def barrido_amplitud(self, ver_origen): """Barrido en amplitud del grafo.""" cola = Cola() while(ver_origen < self.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) if(not vertice['visitado']): vertice['visitado'] = True cola.arribo(vertice) while(not cola.cola_vacia()): nodo = cola.atencion() print(nodo['info'], nodo['data']) aristas = 0 while(aristas < nodo['aristas'].tamanio()): adyacente = nodo['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(adyacente['destino']) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) if(not nuevo_vertice['visitado']): nuevo_vertice['visitado'] = True cola.arribo(nuevo_vertice) aristas += 1 ver_origen += 1 def marcar_no_visitado(self): """Marca todos losvertices del grafo como no visitados.""" for i in range(self.tamanio()): self.inicio.obtener_elemento(i)['visitado'] = False def existe_paso(self, ver_origen, ver_destino): """Barrido en profundidad del grafo.""" resultado = False vertice = self.inicio.obtener_elemento(ver_origen) if(not vertice['visitado']): vertice['visitado'] = True aristas = 0 while(aristas < vertice['aristas'].tamanio() and not resultado): arista = vertice['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(arista['destino']) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) destino = self.inicio.obtener_elemento(ver_destino) if(nuevo_vertice['info'] == destino['info']): return True else: resultado = self.existe_paso(pos_vertice, ver_destino) aristas += 1 return resultado def dijkstra(self, ver_origen, ver_destino): """Algoritmo de Dijkstra para hallar el camino mas corto.""" no_visitados = HeapMin() camino = Pila() aux = 0 while(aux < self.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) vertice_aux = self.inicio.obtener_elemento(aux) vertice_aux['anterior'] = None if(vertice_aux['info'] == vertice['info']): no_visitados.arribo([vertice_aux['info'], None], 0) else: no_visitados.arribo([vertice_aux['info'], None], inf) aux += 1 while(not no_visitados.vacio()): dato = no_visitados.atencion() camino.apilar(dato) pos_aux = self.buscar_vertice(dato[1][0]) vertice_aux = self.inicio.obtener_elemento(pos_aux) aristas = 0 while(aristas < vertice_aux['aristas'].tamanio()): arista = vertice_aux['aristas'].obtener_elemento(aristas) pos_heap = no_visitados.busqueda(arista['destino']) if(pos_heap is not None and no_visitados.elementos[pos_heap][0] > dato[0] + arista['peso']): no_visitados.elementos[pos_heap][1][1] = dato[1][0] nuevo_peso = dato[0] + arista['peso'] no_visitados.cambiar_prioridad(pos_heap, nuevo_peso) aristas += 1 # print(no_visitados.elementos) return camino def busqueda_prim(self, bosque, buscado): for elemento in bosque: if(buscado in elemento[1]): return elemento def prim(self): """Algoritmo de Prim para hallar el árbol de expansión mínimo.""" bosque = [] aristas = HeapMin() origen = self.inicio.obtener_elemento(0) adyac = 0 while(adyac < origen['aristas'].tamanio()): arista = origen['aristas'].obtener_elemento(adyac) aristas.arribo([origen['info'], arista['destino']], arista['peso']) adyac += 1 # print(bosque) # print(aristas.elementos) # print() while(len(bosque) // 2 < self.tamanio() and not aristas.vacio()): dato = aristas.atencion() if(len(bosque) == 0) or ((self.busqueda_prim(bosque, dato[1][0]) is not None) ^ (self.busqueda_prim(bosque, dato[1][1]) is not None)): bosque.append(dato) pos_vertice = self.buscar_vertice(dato[1][1]) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) adyac = 0 while(adyac < nuevo_vertice['aristas'].tamanio()): arista = nuevo_vertice['aristas'].obtener_elemento(adyac) # print(arista) aristas.arribo([nuevo_vertice['info'], arista['destino']], arista['peso']) adyac += 1 # print(bosque) # print(aristas.elementos) # a = input() return bosque # grafo = Grafo() # grafo.insertar_vertice('A') # grafo.insertar_vertice('C') # grafo.insertar_vertice('B') # grafo.insertar_vertice('F') # grafo.insertar_vertice('Z') # grafo.insertar_vertice('X') # grafo.insertar_arista(5, 'A', 'B') # grafo.insertar_arista(2, 'C', 'B') # grafo.insertar_arista(3, 'B', 'C') # grafo.insertar_arista(9, 'A', 'F') # grafo.insertar_arista(5, 'B', 'F') # grafo.insertar_arista(13, 'F', 'X') # grafo.insertar_arista(7, 'X', 'Z') # grafo.insertar_arista(5, 'C', 'X') # vertice_destino = grafo.buscar_vertice('Z') # vertice_origen = grafo.buscar_vertice('A') # bosque = grafo.prim() # print('arbol de expansion') # peso = 0 # for elemento in bosque: # print(elemento[1][0], '-', elemento[1][1]) # peso += elemento[0] # print('costo total', peso) # pila_camino = grafo.dijkstra(vertice_origen, vertice_destino) # destino = 'Z' # costo = None # while(not pila_camino.pila_vacia()): # dato = pila_camino.desapilar() # if(dato[1][0] == destino): # if(costo is None): # costo = dato[0] # print(dato[1][0]) # destino = dato[1][1] # print('el costo total del camino es:', costo) # print(grafo.existe_paso(vertice_origen, vertice_destino)) # grafo.barrido_profundidad(vertice_origen) # grafo.marcar_no_visitado() # print() # vertice_origen = grafo.buscar_vertice('F') # grafo.barrido_amplitud(vertice_origen) # grafo.insertar_arista(100, 'B', 'B') # grafo.inicio.obtener_elemento(0)['aristas'].barrido() # print() # grafo.inicio.obtener_elemento(1)['aristas'].barrido() # grafo.barrido_vertices() # print(grafo.es_adyacente('A', 'F')) # print(grafo.es_adyacente('A', 'C')) # # print(grafo.eliminar_vertice('B')) # print() # grafo.barrido_vertices() # print() # grafo.eliminar_arista('A', 'B') # grafo.adyacentes('A') # print() # grafo.adyacentes('F') # print() # grafo.adyacentes('B') # print(grafo.buscar_vertice('F')) # print(grafo.buscar_vertice('B')) # print(grafo.buscar_arista('B','A')) # print(grafo.buscar_arista('A','A'))
from TDA_Lista import Lista # el visual me da un error AttributeError: 'str' object has no attribute 'hora' que no se como se soluciona list = Lista() personajes = ['Scalet Witch', 'Thor', 'Loki', 'Iron Man'] otraLista = ['Loki', 'Black Widow', 'Hulk', 'Rocket Racoonn'] for pers in personajes: list.insertar(pers) print("A") pos = list.busqueda("Thor") # A if (pos != -1): print("Thor esta en la lista, en la posicion ", +pos) else: print("Thor no esta en la lista!") print("B") pos = list.busqueda("Scalet Witch") # B list.modificar_elemento(pos, "Scarlet Witch") print("C") for pers in personajes: # C list.insertar(pers) print("D") list.barrido() #D list.barrido_descendente()
class Grafo(object): def __init__(self, dirigido=True): self.dirigido = dirigido self.inicio = Lista() def insertar_vertice(self, dato, criterio='info', data=None): # ! agregar otro self.inicio.insertar( { 'info': dato, 'visitado': False, 'aristas': Lista(), 'data': data }, criterio) def insertar_arista(self, peso, origen, destino, criterio='destino', data=None): # ! agregar otro ver_origen = self.inicio.busqueda(origen, 'info') ver_destino = self.inicio.busqueda(destino, 'info') if (ver_origen != -1 and ver_destino != -1): self.inicio.obtener_elemento(ver_origen)['aristas'].insertar( { 'peso': peso, 'destino': destino, 'data': data }, criterio) if (not self.dirigido and origen != destino): data_aux = deepcopy(data) if (data): data_aux['relacion'].reverse() self.inicio.obtener_elemento(ver_destino)['aristas'].insertar( { 'peso': peso, 'destino': origen, 'data': data_aux }, criterio) else: print('los vertices origen o destino no estan en el grafo....', origen, destino) def grafo_vacio(self): return self.inicio.lista_vacia() def tamanio(self): return self.inicio.tamanio() def buscar_vertice(self, clave, criterio='info'): return self.inicio.busqueda(clave, criterio=criterio) def buscar_arista(self, origen, destino, criterio='destino'): ver_origen = self.inicio.busqueda(origen, 'info') if (ver_origen != -1): return self.inicio.obtener_elemento( ver_origen)['aristas'].busqueda(destino, criterio) else: return ver_origen def barrido_vertices(self): self.inicio.barrido() def es_adyacente(self, origen, destino): ver_origen = self.inicio.busqueda(origen, 'info') if (ver_origen != -1): destino = self.buscar_arista(origen, destino) if (destino != -1): return True else: return False else: return False def adyacentes(self, origen): ver_origen = self.inicio.busqueda(origen, 'info') if (ver_origen != -1): self.inicio.obtener_elemento(ver_origen)['aristas'].barrido() def eliminar_vertice(self, clave): aux = self.inicio.eliminar(clave, criterio='info') for posicion in range(self.tamanio()): origen = self.inicio.obtener_elemento(posicion)['info'] self.eliminar_arista(origen, clave) return aux def eliminar_arista(self, origen, destino): ver_origen = self.inicio.busqueda(origen, 'info') if (ver_origen != -1): self.inicio.obtener_elemento(ver_origen)['aristas'].eliminar( destino, 'destino') if (not self.dirigido): ver_destino = self.inicio.busqueda(destino, 'info') if (ver_destino != -1): self.inicio.obtener_elemento( ver_destino)['aristas'].eliminar(origen, 'destino') def barrido_profundidad(self, ver_origen): """Barrido en profundidad del grafo.""" while (ver_origen < self.inicio.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) if (not vertice['visitado']): vertice['visitado'] = True print(vertice['info']) aristas = 0 while (aristas < vertice['aristas'].tamanio()): arista = vertice['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(arista['destino']) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) if (not nuevo_vertice['visitado']): self.barrido_profundidad(pos_vertice) aristas += 1 ver_origen += 1 def barrido_amplitud(self, ver_origen): """Barrido en amplitud del grafo.""" cola = Cola() while (ver_origen < self.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) if (not vertice['visitado']): vertice['visitado'] = True cola.arribo(vertice) while (not cola.cola_vacia()): nodo = cola.atencion() print(nodo['info'], nodo['data']) aristas = 0 while (aristas < nodo['aristas'].tamanio()): adyacente = nodo['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(adyacente['destino']) nuevo_vertice = self.inicio.obtener_elemento( pos_vertice) if (not nuevo_vertice['visitado']): nuevo_vertice['visitado'] = True cola.arribo(nuevo_vertice) aristas += 1 ver_origen += 1 def marcar_no_visitado(self): """Marca todos losvertices del grafo como no visitados.""" for i in range(self.tamanio()): self.inicio.obtener_elemento(i)['visitado'] = False def existe_paso(self, ver_origen, ver_destino): """Barrido en profundidad del grafo.""" resultado = False vertice = self.inicio.obtener_elemento(ver_origen) if (not vertice['visitado']): vertice['visitado'] = True aristas = 0 while (aristas < vertice['aristas'].tamanio() and not resultado): arista = vertice['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(arista['destino']) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) destino = self.inicio.obtener_elemento(ver_destino) if (nuevo_vertice['info'] == destino['info']): return True else: resultado = self.existe_paso(pos_vertice, ver_destino) aristas += 1 return resultado def dijkstra(self, ver_origen, ver_destino): """Algoritmo de Dijkstra para hallar el camino mas corto.""" no_visitados = HeapMin() camino = Pila() aux = 0 while (aux < self.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) vertice_aux = self.inicio.obtener_elemento(aux) vertice_aux['anterior'] = None if (vertice_aux['info'] == vertice['info']): no_visitados.arribo([vertice_aux['info'], None], 0) else: no_visitados.arribo([vertice_aux['info'], None], inf) aux += 1 while (not no_visitados.vacio()): dato = no_visitados.atencion() camino.apilar(dato) pos_aux = self.buscar_vertice(dato[1][0]) vertice_aux = self.inicio.obtener_elemento(pos_aux) aristas = 0 while (aristas < vertice_aux['aristas'].tamanio()): arista = vertice_aux['aristas'].obtener_elemento(aristas) pos_heap = no_visitados.busqueda(arista['destino']) if (pos_heap is not None and no_visitados.elementos[pos_heap][0] > dato[0] + arista['peso']): no_visitados.elementos[pos_heap][1][1] = dato[1][0] nuevo_peso = dato[0] + arista['peso'] no_visitados.cambiar_prioridad(pos_heap, nuevo_peso) aristas += 1 # print(no_visitados.elementos) return camino def busqueda_prim(self, bosque, buscado): for elemento in bosque: if (buscado in elemento[1]): return elemento def prim(self): """Algoritmo de Prim para hallar el árbol de expansión mínimo.""" bosque = [] aristas = HeapMin() origen = self.inicio.obtener_elemento(0) adyac = 0 while (adyac < origen['aristas'].tamanio()): arista = origen['aristas'].obtener_elemento(adyac) aristas.arribo([origen['info'], arista['destino']], arista['peso']) adyac += 1 # print(bosque) # print(aristas.elementos) # print() while (len(bosque) // 2 < self.tamanio() and not aristas.vacio()): dato = aristas.atencion() if (len(bosque) == 0) or ( (self.busqueda_prim(bosque, dato[1][0]) is not None) ^ (self.busqueda_prim(bosque, dato[1][1]) is not None)): bosque.append(dato) pos_vertice = self.buscar_vertice(dato[1][1]) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) adyac = 0 while (adyac < nuevo_vertice['aristas'].tamanio()): arista = nuevo_vertice['aristas'].obtener_elemento(adyac) # print(arista) aristas.arribo([nuevo_vertice['info'], arista['destino']], arista['peso']) adyac += 1 # print(bosque) # print(aristas.elementos) # a = input() return bosque # grafo = Grafo() # grafo.insertar_vertice('A') # grafo.insertar_vertice('C') # grafo.insertar_vertice('B') # grafo.insertar_vertice('F') # grafo.insertar_vertice('Z') # grafo.insertar_vertice('X') # grafo.insertar_arista(5, 'A', 'B') # grafo.insertar_arista(2, 'C', 'B') # grafo.insertar_arista(3, 'B', 'C') # grafo.insertar_arista(9, 'A', 'F') # grafo.insertar_arista(5, 'B', 'F') # grafo.insertar_arista(13, 'F', 'X') # grafo.insertar_arista(7, 'X', 'Z') # grafo.insertar_arista(5, 'C', 'X') # vertice_destino = grafo.buscar_vertice('Z') # vertice_origen = grafo.buscar_vertice('A') # bosque = grafo.prim() # print('arbol de expansion') # peso = 0 # for elemento in bosque: # print(elemento[1][0], '-', elemento[1][1]) # peso += elemento[0] # print('costo total', peso) # pila_camino = grafo.dijkstra(vertice_origen, vertice_destino) # destino = 'Z' # costo = None # while(not pila_camino.pila_vacia()): # dato = pila_camino.desapilar() # if(dato[1][0] == destino): # if(costo is None): # costo = dato[0] # print(dato[1][0]) # destino = dato[1][1] # print('el costo total del camino es:', costo) # print(grafo.existe_paso(vertice_origen, vertice_destino)) # grafo.barrido_profundidad(vertice_origen) # grafo.marcar_no_visitado() # print() # vertice_origen = grafo.buscar_vertice('F') # grafo.barrido_amplitud(vertice_origen) # grafo.insertar_arista(100, 'B', 'B') # grafo.inicio.obtener_elemento(0)['aristas'].barrido() # print() # grafo.inicio.obtener_elemento(1)['aristas'].barrido() # grafo.barrido_vertices() # print(grafo.es_adyacente('A', 'F')) # print(grafo.es_adyacente('A', 'C')) # # print(grafo.eliminar_vertice('B')) # print() # grafo.barrido_vertices() # print() # grafo.eliminar_arista('A', 'B') # grafo.adyacentes('A') # print() # grafo.adyacentes('F') # print() # grafo.adyacentes('B') # print(grafo.buscar_vertice('F')) # print(grafo.buscar_vertice('B')) # print(grafo.buscar_arista('B','A')) # print(grafo.buscar_arista('A','A')) ################################################################################### #FUNCIONES DEL EJERCICIO 6 def hijos_dios(self, nombre_dios): """Devuelve una lista con los hijos del dios dado o None si el dios ingresado no está cargado.""" hijos = [] dios = self.buscar_vertice(nombre_dios) if (dios != -1): aristas = self.inicio.obtener_elemento(dios)['aristas'] for i in range(aristas.tamanio()): elemento = aristas.obtener_elemento(i) if (elemento['data'] == 'padre' or elemento['data'] == 'madre'): hijos.append(elemento['destino']) return hijos else: return None def familia_dios(self, nombre_dios): """Funcion que devuelve tres listas (padres, hijos y hermanos) en base al dios dado, o None si el dios ingresado no está cargado.""" dios = self.buscar_vertice(nombre_dios) if (dios != -1): padres = [] hijos = [] hermanos = [] aristas = self.inicio.obtener_elemento(dios)['aristas'] for i in range(aristas.tamanio()): elemento = aristas.obtener_elemento(i) if (elemento['data'] == 'hijo/a'): padres.append(elemento['destino']) elif (elemento['data'] == 'padre' or elemento['data'] == 'madre'): hijos.append(elemento['destino']) elif (elemento['data'] == 'hermano/a'): hermanos.append(elemento['destino']) return padres, hijos, hermanos else: return None, None, None def relacion_dioses(self, vertice_origen, vertice_destino): """Devuelve una lista con la/s relacion/es encontradas entre dos dioses, una lista vacia si no existe relacion.""" relacion = [] if (self.es_adyacente(vertice_origen, vertice_destino)): dios = self.buscar_vertice(vertice_origen) aristas = self.inicio.obtener_elemento(dios)['aristas'] for i in range(aristas.tamanio()): elemento = aristas.obtener_elemento(i) if (vertice_destino == elemento['destino']): relacion.append(elemento['data']) return relacion def madre_dios(self, nombre_dios): """Recorre lista de aristas de un dios y devuelve el nombre de su madre, o None si no tiene.""" dios = self.buscar_vertice(nombre_dios) aristas = self.inicio.obtener_elemento(dios)['aristas'] madre = None for i in range(aristas.tamanio()): elemento = aristas.obtener_elemento(i) if (elemento['data'] == 'hijo/a'): pos = self.buscar_vertice(elemento['destino']) if ( self.inicio.obtener_elemento( pos)['data']['genero'] == 'F' ): #se verifica que el genero sea F para que no muestre al padre madre = elemento['destino'] return madre #devuelve None si el dios no tiene madre def barrido_profundidad_dioses_madres(self, ver_origen): """Barrido en profundidad del grafo mostrando solo a los dioses que tienen madres, utilizando la funcion madre_dios.""" while (ver_origen < self.inicio.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) if (not vertice['visitado']): vertice['visitado'] = True madre = self.madre_dios(vertice['info']) if (not madre == None ): #para mostrar unicamente a los dioses que tienen madre print(vertice['info'], ' - Madre:', madre) aristas = 0 while (aristas < vertice['aristas'].tamanio()): arista = vertice['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(arista['destino']) nuevo_vertice = self.inicio.obtener_elemento(pos_vertice) if (not nuevo_vertice['visitado']): self.barrido_profundidad_dioses_madres(pos_vertice) aristas += 1 ver_origen += 1 def ancestros_dios(self, nombre_dios, ancestros): """Carga en la lista dada los nombres de los ancestros del dios dado.""" dios = self.buscar_vertice(nombre_dios) aristas = self.inicio.obtener_elemento(dios)['aristas'] for i in range(aristas.tamanio()): elemento = aristas.obtener_elemento(i) if (elemento['data'] == 'hijo/a'): if (elemento['destino'] not in ancestros): ancestros.append(elemento['destino']) self.ancestros_dios(elemento['destino'], ancestros) def nietos_dios(self, nombre_dios): """Devuelve una lista con los nietos de un dios dado accediendo a los hijos de éste y usando hijos_dios para agregar a los hijos de cada uno a la lista de nietos.""" nietos = [] dios = self.buscar_vertice(nombre_dios) aristas = self.inicio.obtener_elemento(dios)['aristas'] for i in range(aristas.tamanio()): elemento = aristas.obtener_elemento(i) if (elemento['data'] == 'padre' or elemento['data'] == 'madre'): hijos = self.hijos_dios(elemento['destino']) for i in range(len(hijos)): if hijos[i] not in nietos: nietos.append(hijos[i]) return nietos