def __init__(self, rens, cols, pasillos, entrada, salida):
self.__laberinto = Array2D(rens, cols, '1')
for pasillo in pasillos:
self.__laberinto.set_item(pasillo[0], pasillo[1], '0')
self.set_entrada(entrada[0], entrada[1])
self.set_salida(salida[0], salida[1])
self.__camino = Stack()
self.__previa = None
class LaberintoADT: #crear el laberinto
"""
0 pasillo, 1 pared, S salida, E entrada
pasillo es una tupla((2,1), (2,2), (2,3), (2,4), (3,2), (4,2))
entrada en una tupla (5,2)
salida(2,5)
"""
def __init__(self, rens, cols, pasillos, entrada, salida):
self.__laberinto=Array2D(rens, cols, '1')
for pasillo in pasillos:
self.__laberinto.set_item(pasillo[0], pasillo[1], '0')
self.set_entrada(entrada[0], entrada[1])
self.set_salida(salida[0], salida[1])
self.__camino=Stack()
self.__previa=None
def to_string(self):
self.__laberinto.to_string()
def mostrar(self):
self.__laberinto.to_string()
"""
establece la entrada de 'E' en la matriz, verificar limites
"""
def set_entrada(self, ren, col):
#Terminar validacion de coordenada
self.__laberinto.set_item(ren, col, 'E')
"""
Establece salida, dentro de los limites perifericos de la matriz
"""
def set_salida(self, ren, col):
#Terminar validacion
self.__laberinto.set_item(ren, col, 'S')
def es_salida(self, ren, col):
return self.__laberinto.get_item(ren, col)=='S'
def buscar_entrada(self):
encontrado=False
for renglon in range(self.__laberinto.get_num_rows()):
for columna in range(self.__laberinto.get_num_cols()):
if self.__laberinto.get_item(renglon, columna)=='E':
self.__camino.push(tuple(renglon, columna))
encontrado=True
return encontrado
def set_previa(self, pos_previa):
self.__previa=pos_previa
def get_previa(self):
return self.__previa
def resolver_laberinto(self):
if self.is_empty():
print("pila vacia")
else:
return self.__data.pop()
def push(self,value):
self.__data.append(value)
def peek(self):
return self.__data[len(self.__data)-1]
def to_string(self):
print(" -----")
for item in self.__data[::-1]:
print(f"|{item}|")
print(" -----")
-----------------------------------------
from pila import Stack
pila=Stack()
pila.push('a')
pila.push('x')
pila.to_string()
pila.push('b')
pila.push('y')
pila.to_string()
var=pila.pop()
pila.to_string()
print(f"var={var}")
def main():
rev = Stack()
rev.push(1)
rev.push(2)
rev.push(3)
rev.push(4)
rev.push(5)
rev.push(6)
rev.push(7)
eliminar_mitad(rev, round(rev.length() / 2), 0)
print("Eliminando la posicion media")
rev.to_string()
print(
f"La posicion eliminada fue {rev.length()/2+1} al ser el elemento de la posicion media"
)
def main():
pil = Stack()
pil.push(8)
pil.push(7)
pil.push(6)
pil.push(5)
pil.push(4)
pil.push(3)
pil.push(2)
find_midle_value(pil)
pil.to_string()
def find_midle_value(pila):
p = Stack()
c = (pila.length() / 2)
pop_stack(
pila, int(c), p
) #Correccion se me olvido poner la pila de ayuda en la funcion pop_stack().
from Ejercicios import pila_posicion_media_rec, contador_reversible_rec
from pila import Stack
print("Prueba ejercicio 3:")
cuenta_regresiva = contador_reversible_rec(3)
print("")
print("Prueba ejercicio 2:")
pila = Stack()
pila.push(2)
pila.push(8)
pila.push(4)
pila.to_string()
elem_medio, pila = pila_posicion_media_rec(pila, pila.length())
print(f"El elemento medio de la pila es {elem_medio} y la pila queda asi:")
pila.to_string()
from pila import Stack
pila = Stack()
pila.push("a")
pila.push("x")
pila.to_string()
pila.push("b")
pila.push("y")
pila.to_string()
var = pila.pop()
pila.to_string()
print(f"var = {var}")
class LaberintoADT: #crear el laberinto
"""
0 pasillo, 1 pared, S salida, E entrada
pasillo es una tupla((2,1), (2,2), (2,3), (2,4), (3,2), (4,2))
entrada en una tupla (5,2)
salida(2,5)
"""
def __init__(self, rens, cols, pasillos, entrada, salida):
self.__laberinto = Array2D(rens, cols, '1')
for pasillo in pasillos:
self.__laberinto.set_item(pasillo[0], pasillo[1], '0')
self.set_entrada(entrada[0], entrada[1])
self.set_salida(salida[0], salida[1])
self.__camino = Stack()
self.__previa = None
def to_string(self):
self.__laberinto.to_string()
def mostrar(self):
self.__laberinto.to_string()
"""
establece la entrada de 'E' en la matriz, verificar limites
"""
def set_entrada(self, ren, col):
#Terminar validacion de coordenada
self.__laberinto.set_item(ren, col, 'E')
"""
Establece salida, dentro de los limites perifericos de la matriz
"""
def set_salida(self, ren, col):
#Terminar validacion
self.__laberinto.set_item(ren, col, 'S')
def es_salida(self, ren, col): #posicion actual es salida?
return self.__laberinto.get_item(ren, col) == 'S'
def buscar_entrada(self):
encontrado = False
for renglon in range(self.__laberinto.get_num_rows()):
for columna in range(self.__laberinto.get_num_cols()):
if self.__laberinto.get_item(renglon, columna) == 'E':
self.__camino.push((renglon, columna))
encontrado = True
return encontrado
def set_previa(self, pos_previa):
self.__previa = pos_previa
def get_previa(self):
return self.__previa
def imprimir_camino(self):
self.__camino.to_string()
def get_pos_actual(self):
return self.__camino.peek()
def resolver_laberinto(self):
actual = self.__camino.peek() #(5, 2)
#buscar izquierda
#agregar validaciones para los limites del laberinto
if actual[1] - 1 != -1 and self.__laberinto.get_item(
actual[0], actual[1] - 1) == '0' and self.get_previa() != (
actual[0], actual[1] - 1) and self.__laberinto.get_item(
actual[0], actual[1] - 1) != 'X':
self.set_previa(actual)
self.__camino.push((actual[0], actual[1] - 1))
#buscar arriba
elif actual[0] - 1 != -1 and self.__laberinto.get_item(
actual[0] - 1, actual[1]) == '0' and self.get_previa() != (
actual[0] - 1, actual[1]) and self.__laberinto.get_item(
actual[0] - 1, actual[1]) != 'X':
self.set_previa(actual)
self.__camino.push((actual[0] - 1, actual[1]))
#buscar derecha
elif 1 == 0:
pass
#buscar abajo
elif 1 == 0:
pass
else:
self.__laberinto.set_item(actual[0], actual[1], 'X')
self.__previa = actual
self.__camino.pop()
class LaberintoADT:
# 0 Pasillo
# 1 Pared
# S salida
# E entrada
#Pasillos es una tupla((2,1),(2,2),(2,3),(2,4),(3,2),(4,2))
#Entrada en una tupla (5,1)
#Salida en una tupla (2,5)
def __init__(self, rens, cols, pasillos, entrada, salida):
self.__laberinto = Array2D(rens, cols, '1')
for pasillo in pasillos:
self.__laberinto.set_item(pasillo[0],pasillo[1],'0')
self.set_entrada(entrada[0],entrada[1]) #Añadido hoy 3 de diciembre de 2020
self.set_salida(salida[0],salida[1]) # Añadido hoy 3 de diciembre de 2020
self.__camino = Stack() #Anñadido hoy 3 de diciembre de 2020
self.__previa = None #Añadido hoy 3 de diciembre de 2020
def to_string(self):
self.__laberinto.to_string()
#Creado hoy 3 de diciembre de 2020
"""
Establece la entrada poniendo una 'E' en la matriz, verificar limites perifericos
"""
def set_entrada(self, ren, col):
try:
self.__laberinto.set_item(ren, col, 'E')
except Exception as e:
print("Cordenadas fuera de rango del laberinto")
"""
Establecer la salida dentro de los limites perifericos de la matriz
"""
def set_salida(self, ren, col):
try:
self.__laberinto.set_item(ren, col, 'S')
except Exception as e:
print("Cordenadas fuera de rango del laberinto")
def es_salida(self, ren, col): #En la posicion actual es salida?
return self.__laberinto.get_item(ren, col) == 'S'
def buscar_entrada(self):
encontrado = False
for renglon in range(self.__laberinto.get_num_rows()):
for columna in range(self.__laberinto.get_num_cols()):
if self.__laberinto.get_item(renglon,columna) == 'E':
self.__camino.push((renglon,columna))
encontrado = True
return encontrado
def set_previa(self, pos_previa):
self.__previa = pos_previa
def get_previa(self):
return self.__previa
#Creado hoy 8 de diciembre de 2020
def imprimir_camino(self):
self.__camino.to_string()
def get_pos_actual(self):
return self.__camino.peek()
def resolver_laberinto(self):
actual = self.__camino.peek()
#Buscar a la izquierda
#Agregar validaciones para limites del laberinto
if actual[1]-1 != -1 and self.__laberinto.get_item(actual[0], actual[1]-1) == '0' and self.get_previa() != (actual[0], actual[1]-1) and self.__laberinto.get_item(actual[0], actual[1]-1) != 'X':
self.set_previa(actual)
self.__camino.push((actual[0], actual[1]-1))
#Buscar arriba
elif actual[0]-1 != -1 and self.__laberinto.get_item(actual[0]-1, actual[1]) == '0' and self.get_previa() != (actual[0]-1, actual[1]) and self.__laberinto.get_item(actual[0]-1, actual[1]) != 'X':
self.set_previa(actual)
self.__camino.push((actual[0]-1, actual[1]))
#Buscar derecha
elif 1==0:
pass
#Buscar abajo
elif 1 == 0:
pass
else:
self.__laberinto.set_item(actual[0], actual[1], 'X')
self.__previa = actual
self.__camino.pop()