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 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)
