def recorrer(self): self.lista_puertos.agregar_puerto(puerto.Puerto(0)) iteraciones = 1 while self.saber_cuando_parar(iteraciones): if sis.preguntar_puerto_actual()[1]: print("cagaste") break puerto_actual = self.lista_puertos.ultimo_agregado puerto_actual.posibles_conexiones = sis.posibles_conexiones() self.siguiente(puerto_actual) iteraciones += 1
def camino(punto_inicio, punto_final): punto_actual = sistema.preguntar_puerto_actual() puertos = ListaLigada() conexion_ocupada = ListaLigada() numero_conexciones = ListaLigada() tipo_conexcion = ListaLigada() las_listas = ListaLigada() while punto_actual[0] != punto_final: conexciones = sistema.posibles_conexiones() numero_conexciones.agregar_nodo(conexciones) pos = puertos.posicion(punto_actual[0], conexion_ocupada, tipo_conexcion) if pos is not False: puertos.agregar_nodo(punto_actual[0]) conec = conexion_ocupada.obtener(pos) if conec + 1 > conexciones - 1: conec = -1 sistema.hacer_conexion(conec + 1) conexion_ocupada.agregar_nodo(conec + 1) punto_actual = sistema.preguntar_puerto_actual() else: puertos.agregar_nodo(punto_actual[0]) sistema.hacer_conexion(0) conexion_ocupada.agregar_nodo(0) punto_actual = sistema.preguntar_puerto_actual() if punto_actual[1]: tipo_conexcion.agregar_nodo(-1) else: tipo_conexcion.agregar_nodo(0) # En tipo 0=normal, -1=me atraparon, 1=alt o random conexciones = sistema.posibles_conexiones() puertos.agregar_nodo(punto_final) numero_conexciones.agregar_nodo(conexciones) conexion_ocupada.agregar_nodo(0) tipo_conexcion.agregar_nodo(-1) las_listas.agregar_nodo(puertos) las_listas.agregar_nodo(conexion_ocupada) las_listas.agregar_nodo(numero_conexciones) las_listas.agregar_nodo(tipo_conexcion) return las_listas
def generar_red(): """ La idea es abrcar lo mas que se pueda la red que desconocemos e ir guardando el camino que vamos tomando para que efectivamente el programa pueda tarminar. Mi programa se dentendra cuando hayamos visitado el puerto de bummer un numero determinado de veces. Los problemas que tiene este algoritmo son que el tiempo de ejecucion es variable y que se segura que hayamos visto el 100% de los nodos, sin embargo, si la red tiene al rededor de 1200 nodos, al pasar 5 veces por bummer habremos encontrado aprox el 99% de los nodos. """ red = Red() puerto_final_ide = sis.puerto_final() puerto_actual = Puerto(sis.puerto_inicio(), sis.posibles_conexiones(), sis.get_capacidad()) i = 0 red.agregar_puerto(puerto_actual) while i < 10: n = puerto_actual.proxima_conexion sis.hacer_conexion(n) puerto_anterior = puerto_actual m = sis.preguntar_puerto_actual()[0] atrapado = sis.preguntar_puerto_actual()[1] if m in red.puertos: puerto_actual = red.puertos[m] # 1 else: puerto_actual = Puerto(m, sis.posibles_conexiones(), sis.get_capacidad()) red.agregar_puerto(puerto_actual, puerto_anterior, n, atrapado) # 2 if puerto_actual.ide == puerto_final_ide: puerto_actual.bummer = True print('Encontramos Bummer') i += 1 print('Red Generada') return red
def rellernar_el_mapa(lista): puertos = lista.obtener(0) conexion_ocupada = lista.obtener(1) numero_conexciones = lista.obtener(2) tipo_conexion = lista.obtener(3) nodos_listos = ListaLigada() todos_nodos = puertos.cabeza nodo = puertos.cabeza c = 0 while todos_nodos: if nodos_listos.esta_dentro(todos_nodos.valor) is False: pos = puertos.posicion(todos_nodos.valor, conexion_ocupada, tipo_conexion) ultima_conexion = conexion_ocupada.obtener(pos) max_conexiones = numero_conexciones.obtener(pos) if ultima_conexion == max_conexiones - 1: nodos_listos.agregar_nodo(todos_nodos.valor) todos_nodos = todos_nodos.siguiente else: while ultima_conexion != max_conexiones - 1: print('a') a = 0 tipo = tipo_conexion.cabeza nodos = ListaLigada() conec = ListaLigada() numconec = ListaLigada() tip = ListaLigada() while nodo.valor != todos_nodos.valor: sistema.hacer_conexion(conexion_ocupada.obtener(a)) punto_actual = sistema.preguntar_puerto_actual() if punto_actual[0] == nodo.siguiente.valor: nodos.agregar_nodo(nodo.valor) conec.agregar_nodo(conexion_ocupada.obtener(a)) numconec.agregar_nodo(numero_conexciones.obtener(a)) tip.agregar_nodo(tipo_conexion.obtener(a)) nodo = nodo.siguiente tipo = tipo.siguiente a += 1 elif tipo_conexion.obtener(a) == -1: camino(punto_actual[0], nodo.siguiente.valor) nodo = nodo.siguiente tipo = tipo.siguiente nodos = ListaLigada() conec = ListaLigada() numconec = ListaLigada() tip = ListaLigada() a += 1 elif punto_actual[1]: nodo = puertos.cabeza tipo = tipo_conexion.cabeza nodos = ListaLigada() conec = ListaLigada() numconec = ListaLigada() tip = ListaLigada() a = 0 else: nodos.agregar_nodo(nodo.valor) conec.agregar_nodo(conexion_ocupada.obtener(a)) numconec.agregar_nodo(numero_conexciones.obtener(a)) tip.agregar_nodo(1) nodos.agregar_nodo(punto_actual[0]) conec.agregar_nodo(-1) numconec.agregar_nodo(sistema.posibles_conexiones()) tip.agregar_nodo(-1) camino(punto_actual[0], nodo.siguiente.valor) tipo = tipo.siguiente nodo = nodo.siguiente a += 1 sistema.hacer_conexion(conexion_ocupada.obtener(pos) + 1) punto_actual = sistema.preguntar_puerto_actual() if punto_actual[1] is True: pass else: nodos.agregar_nodo(nodo.valor) conec.agregar_nodo(conexion_ocupada.obtener(pos) + 1) numconec.agregar_nodo(numero_conexciones.obtener(a)) tip.agregar_nodo(0) nodos.agregar_nodo(punto_actual[0]) conec.agregar_nodo(-1) numconec.agregar_nodo(sistema.posibles_conexiones()) tip.agregar_nodo(-1) tips = tip.cabeza b = 0 while tips: puertos.agregar_nodo(nodos.obtener(b)) conexion_ocupada.agregar_nodo(conec.obtener(b)) numero_conexciones.agregar_nodo(numconec.obtener(b)) tipo_conexion.agregar_nodo(tip.obtener(b)) b += 1 tips = tips.siguiente camino(punto_actual[0], puertos.cabeza.valor) nodo = puertos.cabeza pos = puertos.posicion(todos_nodos.valor, conexion_ocupada, tipo_conexion) ultima_conexion = conexion_ocupada.obtener(pos) nodos_listos.agregar_nodo(todos_nodos.valor) todos_nodos = todos_nodos.siguiente else: todos_nodos = todos_nodos.siguiente print('siguiente nodoooooooooooooooooooooooooo', c) c += 1 print('Eeeeeexitooooo') las_listas = ListaLigada() las_listas.agregar_nodo(puertos) las_listas.agregar_nodo(conexion_ocupada) las_listas.agregar_nodo(numero_conexciones) las_listas.agregar_nodo(tipo_conexion) return las_listas
def mapear_red(self): ''' Se itera sobre la red de modo de encontrar los puertos teniendo el id del puerto actual como el mayor y cambiandolo cada vez que se encuentre uno mayor, de modo de recorrerlos todos. Después se itera un numero indeterminado de veces sobre la red para obtener todas las conexiones. Se detiene una vez que, tras 4 grupos seguidos de 200000 iteraciones, no haya cambiado el numero de conexiones encontradas. En ambos casos (puertos y conexiones) se guardan ids en un arbol binario y objetos en otro arbol o lista, para hacer la comprobación de "objeto in contenedor" de forma óptima. :return: None ''' iteraciones = 0 n_puertos = 0 actual_max = 2 n_conexiones = 0 print('Obteniendo puertos...') while n_puertos <= actual_max: id_actual, atrapado = st.preguntar_puerto_actual() if id_actual not in self.puertos_id: puerto_actual = Puerto(id_actual) self.puertos.add(puerto_actual) self.puertos_id.add(id_actual) # self.lista_puertos.append(puerto_actual) n_puertos += 1 conexiones = st.posibles_conexiones() siguiente_index = choice(range(conexiones)) st.hacer_conexion(siguiente_index) id_siguiente, atrapado = st.preguntar_puerto_actual() if id_siguiente not in self.puertos_id: puerto_siguiente = Puerto(id_siguiente) self.puertos.add(puerto_siguiente) self.puertos_id.add(id_siguiente) # self.lista_puertos.append(puerto_siguiente) n_conexiones += conexiones n_puertos += 1 iteraciones += 1 actual_max = max(actual_max, id_siguiente) n_puertos = len(self.puertos) print('%d puertos encontrados' % n_puertos, 'en %d iteraciones.' % iteraciones) print('Obteniendo conexiones...') estable = 0 n_anterior = 0 while estable < 3: id_actual, atrapado = st.preguntar_puerto_actual() conexiones = st.posibles_conexiones() siguiente_index = choice(range(conexiones)) st.hacer_conexion(siguiente_index) id_siguiente, atrapado = st.preguntar_puerto_actual() if not atrapado: phash = pseudo_hash(id_actual, id_siguiente) if phash not in self.conexiones_id: puerto_actual = self.puertos.find(Puerto(id_actual)) puerto_siguiente = self.puertos.find(Puerto(id_siguiente)) c = Conexion(siguiente_index, puerto_actual, puerto_siguiente) self.conexiones.append(c) self.conexiones_id.add(phash) puerto = self.puertos.find(puerto_actual) if puerto is not None: puerto.conexiones.append(c) if iteraciones % 200000 == 0: if len(self.conexiones) == n_anterior: estable += 1 # comprueba que no cambien las cxs else: estable = 0 n_anterior = len(self.conexiones) print('.', end='') # sublime syntax error, pero cumple pep stdout.flush() iteraciones += 1 print('\n%d conexiones encontradas.' % len(self.conexiones))
def rellernar_el_mapa(lista): puertos = lista.obtener(0) conexion_ocupada = lista.obtener(1) numero_conexciones = lista.obtener(2) tipo_conexion = lista.obtener(3) nodos_listos = ListaLigada() todos_nodos = puertos.cabeza nodo = puertos.cabeza c = 0 while todos_nodos: if nodos_listos.esta_dentro(todos_nodos.valor) is False: pos = puertos.posicion(todos_nodos.valor, conexion_ocupada, tipo_conexion) ultima_conexion = conexion_ocupada.obtener(pos) max_conexiones = numero_conexciones.obtener(pos) if ultima_conexion == max_conexiones - 1: nodos_listos.agregar_nodo(todos_nodos.valor) todos_nodos = todos_nodos.siguiente else: while ultima_conexion != max_conexiones - 1: print('a') a = 0 tipo = tipo_conexion.cabeza nodos = ListaLigada() conec = ListaLigada() numconec = ListaLigada() tip = ListaLigada() while nodo.valor != todos_nodos.valor: sistema.hacer_conexion(conexion_ocupada.obtener(a)) punto_actual = sistema.preguntar_puerto_actual() if punto_actual[0] == nodo.siguiente.valor: nodos.agregar_nodo(nodo.valor) conec.agregar_nodo(conexion_ocupada.obtener(a)) numconec.agregar_nodo( numero_conexciones.obtener(a)) tip.agregar_nodo(tipo_conexion.obtener(a)) nodo = nodo.siguiente tipo = tipo.siguiente a += 1 elif tipo_conexion.obtener(a) == -1: camino(punto_actual[0], nodo.siguiente.valor) nodo = nodo.siguiente tipo = tipo.siguiente nodos = ListaLigada() conec = ListaLigada() numconec = ListaLigada() tip = ListaLigada() a += 1 elif punto_actual[1]: nodo = puertos.cabeza tipo = tipo_conexion.cabeza nodos = ListaLigada() conec = ListaLigada() numconec = ListaLigada() tip = ListaLigada() a = 0 else: nodos.agregar_nodo(nodo.valor) conec.agregar_nodo(conexion_ocupada.obtener(a)) numconec.agregar_nodo( numero_conexciones.obtener(a)) tip.agregar_nodo(1) nodos.agregar_nodo(punto_actual[0]) conec.agregar_nodo(-1) numconec.agregar_nodo( sistema.posibles_conexiones()) tip.agregar_nodo(-1) camino(punto_actual[0], nodo.siguiente.valor) tipo = tipo.siguiente nodo = nodo.siguiente a += 1 sistema.hacer_conexion(conexion_ocupada.obtener(pos) + 1) punto_actual = sistema.preguntar_puerto_actual() if punto_actual[1] is True: pass else: nodos.agregar_nodo(nodo.valor) conec.agregar_nodo(conexion_ocupada.obtener(pos) + 1) numconec.agregar_nodo(numero_conexciones.obtener(a)) tip.agregar_nodo(0) nodos.agregar_nodo(punto_actual[0]) conec.agregar_nodo(-1) numconec.agregar_nodo(sistema.posibles_conexiones()) tip.agregar_nodo(-1) tips = tip.cabeza b = 0 while tips: puertos.agregar_nodo(nodos.obtener(b)) conexion_ocupada.agregar_nodo(conec.obtener(b)) numero_conexciones.agregar_nodo( numconec.obtener(b)) tipo_conexion.agregar_nodo(tip.obtener(b)) b += 1 tips = tips.siguiente camino(punto_actual[0], puertos.cabeza.valor) nodo = puertos.cabeza pos = puertos.posicion(todos_nodos.valor, conexion_ocupada, tipo_conexion) ultima_conexion = conexion_ocupada.obtener(pos) nodos_listos.agregar_nodo(todos_nodos.valor) todos_nodos = todos_nodos.siguiente else: todos_nodos = todos_nodos.siguiente print('siguiente nodoooooooooooooooooooooooooo', c) c += 1 print('Eeeeeexitooooo') las_listas = ListaLigada() las_listas.agregar_nodo(puertos) las_listas.agregar_nodo(conexion_ocupada) las_listas.agregar_nodo(numero_conexciones) las_listas.agregar_nodo(tipo_conexion) return las_listas
def ruta_a_bummer(lista_puertos): lista_conexiones = None return lista_conexiones if __name__ == "__main__": lista_puertos = Lista() ultimo_puerto = None iteraciones = 1 while saber_cuando_parar(iteraciones): puerto_actual = Puerto(sis.preguntar_puerto_actual()[0]) puerto_actual.conexiones_posibles = sis.posibles_conexiones() if puerto_actual.id not in lista_puertos: if len(lista_puertos) == 0: # agregar el primer puerto nodo_actual = Nodo(puerto_actual) lista_puertos.add_nodo(nodo_actual) else: nodo_actual = Nodo(puerto_actual) nodo_anterior = lista_puertos.ultimo nodo_anterior.valor.hijos.add_nodo(Nodo(puerto_actual.id)) nodo_actual.valor.padres.add_nodo(Nodo(nodo_anterior.valor.id)) lista_puertos.add_nodo(nodo_actual) else: nodo_actual = lista_puertos.get_nodo(puerto_actual.id) # obener nodo nodo_padre = lista_puertos.get_nodo(ultimo_puerto)