def ejercicio_16():
obj_Pila = Pila()
obj_Pila2 = Pila()
obj_Interseccion_Pila = Pila()
personajes_Star_Wars_EP_V = [
'Luke Skywalker', 'Han Solo', 'Darth Vader', 'Leia Organa', 'Yoda',
'Capitán Needan', 'Almirante Ozzel', 'Lando Calrissian'
]
personajes_Star_Wars_EP_VII = [
'Kylo Ren', 'Rey', 'Han Solo', 'Luke Skywalker', 'C3PO', 'Leia Organa',
'Chewbacca', ' Poe Dameron'
]
for i in range(0, len(personajes_Star_Wars_EP_V)):
obj_Pila.apilar(personajes_Star_Wars_EP_V[i])
for i in range(0, len(personajes_Star_Wars_EP_VII)):
obj_Pila2.apilar(personajes_Star_Wars_EP_VII[i])
obj_Interseccion_Pila = get_Interseccion_De_Pilas(obj_Pila, obj_Pila2)
while (not obj_Interseccion_Pila.pila_vacia()):
print('El personaje ', obj_Interseccion_Pila.desapilar(),
' esta en ambas peliculas')
def palindromo(cola):
piladerecha = Pila()
pilaizquierda = Pila()
t = cola.tamanio
cont = 0
mitad = (t // 2)
while (not cola_vacia(cola)):
a = atencion(cola)
cont += 1
if (t % 2 == 0):
if (cont <= mitad):
apilar(piladerecha, a)
elif (cont >= mitad + 1):
apilar(pilaizquierda, a)
else:
if (cont <= mitad):
apilar(piladerecha, a)
elif (cont >= mitad + 2):
apilar(pilaizquierda, a)
print(piladerecha.datos)
print(invertirPila(pilaizquierda).datos)
if (compararpilas(pilaizquierda, piladerecha) == True):
print("La palabra es palindroma.")
else:
print("La palabra no es palindroma.")
def sumar_pilas(pila1, pila2):
"""
DOC: Completar
"""
pila1_invertida = Pila()
pila2_invertida = Pila()
pila_final = Pila()
while not pila1.esta_vacia() or not pila2.esta_vacia():
n1 = pila1.desapilar() if not pila1.esta_vacia() else 0
n2 = pila2.desapilar() if not pila2.esta_vacia() else 0
pila1_invertida.apilar(n1) if not n1 == 0 else None
pila2_invertida.apilar(n2) if not n2 == 0 else None
while not pila1_invertida.esta_vacia or not pila2_invertida.esta_vacia():
numero_anterior = pila_final.desapilar(
) if not pila_final.esta_vacia() else 0
n1 = pila1_invertida.desapilar(
) if not pila1_invertida.esta_vacia() else 0
n2 = pila2_invertida.desapilar(
) if not pila2_invertida.esta_vacia() else 0
print(n1, n2)
suma = n1 + n2
suma += numero_anterior
proximo_numero = suma // 10
suma = suma % 10
pila_final.apilar(suma)
pila_final.apilar(proximo_numero) if not proximo_numero == 0 else None
return pila_final
def ejericcio_12():
obj_Pila = Pila()
obj_Pila2 = Pila()
obj_Pila3 = Pila()
obj_Pila.apilar('Boba Fet')
obj_Pila.apilar('Leia Organa')
obj_Pila.apilar('Darth Vader')
obj_Pila.apilar('Yoda')
obj_Pila.apilar('Chewbacca')
obj_Pila.apilar('Obi-Wan Kenobi')
obj_Pila.apilar('R2-D2')
obj_Pila.apilar('C3PO')
obj_Pila2.apilar('Leia Organa')
obj_Pila2.apilar('Darth Vader')
obj_Pila2.apilar('Yoda')
obj_Pila2.apilar('Chewbacca')
obj_Pila2.apilar('Obi-Wan Kenobi')
obj_Pila2.apilar('R2-D2')
obj_Pila2.apilar('C3PO')
obj_Pila3.apilar('Darth Vader')
obj_Pila3.apilar('Yoda')
obj_Pila3.apilar('Chewbacca')
obj_Pila3.apilar('Obi-Wan Kenobi')
obj_Pila3.apilar('R2-D2')
obj_Pila3.apilar('C3PO')
print(existe_Leila_O_Boba_En_Pila(obj_Pila))
print(existe_Leila_O_Boba_En_Pila(obj_Pila2))
print(existe_Leila_O_Boba_En_Pila(obj_Pila3))
def get_Interseccion_De_Pilas(obj_Pila_1, Obj_Pila_2):
elemento = None
obj_aux_Pila = Pila()
obj_aux_Pila_2 = Pila()
obj_Interseccion_Pila = Pila()
while (not obj_Pila_1.pila_vacia()):
while (not Obj_Pila_2.pila_vacia()):
elemento = Obj_Pila_2.desapilar()
obj_aux_Pila_2.apilar(elemento)
if (elemento == obj_Pila_1.elemento_cima()):
obj_Interseccion_Pila.apilar(elemento)
obj_aux_Pila.apilar(obj_Pila_1.desapilar())
#Devuelvo elementos a la pila 2 para devolverla a como estaba
while (not obj_aux_Pila_2.pila_vacia()):
Obj_Pila_2.apilar(obj_aux_Pila_2.desapilar())
#Devuelvo elementos a la pila 1 para devolverla a como estaba
while (not obj_aux_Pila.pila_vacia()):
obj_Pila_1.apilar(obj_aux_Pila.desapilar())
return obj_Interseccion_Pila
def invertir(cola):
pila1 = Pila()
pilaInvertida = Pila()
while not (cola_vacia(cola)):
a = atencion(cola)
apilar(pila1, a)
while not (pila_vacia(pila1)):
a = desapilar(pila1)
apilar(pilaInvertida, a)
return pilaInvertida
def cfc(grafo):
visitados = set()
orden = {}
p = Pila()
s = Pila()
cfcs = []
en_cfs = set()
for v in grafo:
if v not in visitados:
orden[v] = 0
dfs_cfc(grafo, v, visitados, orden, p, s, cfcs, en_cfs)
return cfcs
def main():
niveles = cargar_niveles()
nivel = 1
teclas = cargar_teclas()
juego = setear_juego(niveles, nivel)
movimientos = Pila()
soluciones = Pila()
mensaje = ""
while gamelib.is_alive():
gamelib.draw_begin()
dibujar(juego)
gamelib.draw_end()
gamelib.draw_text(mensaje,15,15,anchor="w")
ev = gamelib.wait(gamelib.EventType.KeyPress)
if not ev: break
tecla = ev.key
if tecla in teclas:
if teclas[tecla] == "REINICIAR":
juego = reiniciar(juego, niveles, nivel, soluciones)
elif teclas[tecla] == "SALIR":
break
elif teclas[tecla] == "DESHACER":
if movimientos.tope:
juego = deshacer(movimientos, juego)
elif teclas[tecla] == "AYUDA":
if soluciones.esta_vacia():
gamelib.draw_text("Pensando...", 15, 15, anchor="w")
gamelib.get_events() #Utilizo .get_events() como una especie de mutex para evitar que el usuario interactúe
solucion_encontrada, soluciones = solver.buscar_solucion(juego, DIRECCIONES)
gamelib.get_events()
if solucion_encontrada:
mensaje = "Hay pista disponible"
else:
mensaje = "No hay chance"
else:
movimientos.apilar(juego)
juego = soko.mover(juego, soluciones.desapilar())
else:
movimientos.apilar(juego)
juego = soko.mover(juego, DIRECCIONES[teclas[tecla]])
if tecla and not teclas[tecla] == "AYUDA":
soluciones = Pila()
mensaje = ""
if soko.juego_ganado(juego):
nivel = nivel + 1
juego = setear_juego(niveles, nivel)
movimientos = Pila()
def invertir_Pila_Sin_Perder_Elementos(pila_a_invertir):
pila_Inversa = Pila()
aux_Pila = Pila()
#me da la pila invertida
while (not pila_a_invertir.pila_vacia()):
elemento = pila_a_invertir.desapilar()
pila_Inversa.apilar(elemento)
aux_Pila.apilar(elemento)
#le devuelvo los elementos que desapile a la pila original
while (not aux_Pila.pila_vacia()):
pila_a_invertir.apilar(aux_Pila.desapilar())
return pila_Inversa
def __init__(self, size):
self.pila = Pila()
self.pila.push('$')
self.pila.push('0')
self.columna = 0
self.cantidad = size
self.accion = ""
def topologico_dfs(grafo):
visitados = set()
pila = Pila()
for v in grafo:
if v not in visitados:
_dfs(grafo, v, visitados, pila)
return pila_a_lista(pila)
def orden_topologico_dfs(grafo):
visitados = set()
pila = Pila()
for v in grafo:
if v not in visitados:
_orden_topologico_dfs(grafo, v, pila, visitados)
return pila.convertir_a_lista()
class Elemento:
pilaC = Pila()
dic = []
listaC = [
y.split(' ') for y in
[x.strip('\n') for x in open("caracteres.txt", 'r').readlines()]
]
i = 0
for x in listaC:
for element in x:
if (element == '+' or element == '-' or element == '*'
or element == '/'):
puntder = float(pilaC.desapilar())
puntizq = float(pilaC.desapilar())
if element == '+':
pilaC.apilar(puntizq + puntder)
if element == '-':
pilaC.apilar(puntizq - puntder)
if element == '*':
pilaC.apilar(puntizq * puntder)
if element == '/':
pilaC.apilar(puntizq / puntder)
else:
#print (element)
if (element == '='):
m = pilaC.desapilar()
n = pilaC.desapilar()
print m
print n
dic.append(m)
dic.append(n)
if (element != '='):
pilaC.apilar(element)
print(dic)
def __init__(self, elemento):
"""
Inicializa el iterador a partir del nodo
parametrizado.
"""
self.actual = elemento
self.anteriores = Pila()
def ejercicio_24():
Mat = None
Vector = None
obj_Personajes_Marvel_Pila = Pila()
# MCU = [['Black Widow', 'Avengers Confidential', 'Iron Man: Rise of Technovore', 'Avengers: Infinity War'],
# ['Iron Man', 'Iron Man I', 'Iron Man II','Avengers Confidential', 'Iron Man: Rise of Technovore', 'The Invincible Iron Man', 'Avengers: Infinity War'],
# ['Hulk', 'Avengers Confidential', 'Hulk vs Thor', 'Avengers: Infinity War'],
# ['Hawkeye', 'Avengers Confidential'],
# ['Thor', 'Hulk vs Thor', 'Avengers: Infinity War'],
# ['Groot', 'Infinity War']
# ['Rocket Raccoon', 'Infinity War']]
MCU = [['Black Widow', 1, 3, 4, 5, 2, 4], ['Rocket Raccoon', 3, 7],
['Iron Man', 1, 3, 4, 5, 2, 4, 7, 9], ['Hulk', 9, 3, 4, 6],
['Hawkeye', 3], ['Groot', 2], ['Thor', 3, 4, 2, 1]]
for i in range(0, len(MCU)):
obj_Personajes_Marvel_Pila.apilar(MCU[i])
#A
print('\nPosicion de Groot y Rocket en la pila\n')
print(
get_mensaje_Posicion_De_Groot_And_Rocket(
get_Pos_Groot_And_Roket(obj_Personajes_Marvel_Pila)))
#B
print('\nPersonajes que aparecen en mas de 5 peliculas')
Mat = get_Personajes_Que_Aparecen_En_Mas_De_5_Peliculas_And_La_Cantidad(
obj_Personajes_Marvel_Pila)
if ((len(Mat) - 1) > 0):
for i in range(0, (len(Mat) - 1)):
print('\nNombre: ', Mat[i][0], '\nTotal Peliculas: ', Mat[i][1])
else:
print(
'\nNingun personaje de MCU en la pila que aparezca en mas de 5 peliculas'
)
#C
print('\nCantidad de peliculas en las que aparece Black Widow')
print(
'\n',
get_Mensaje_Black_Widow(
get_Cantidad_Peliculas_En_La_Que_Aparece_Black_Widow(
obj_Personajes_Marvel_Pila)))
#D
print('\nPersonajes que empiecen con C, D o G')
Vector = get_Nombres_Que_Empiezan_Con_C_D_And_G(obj_Personajes_Marvel_Pila)
if ((len(Vector) - 1) > 0):
for i in range(0, (len(Vector) - 1)):
print('\nNombre: ', Vector[i])
else:
print(
'\nNo hay personajes de MCU en la pila que empiecen con C, D o G')
#-------------------------FIN#-------------------------
def insertar_El_Numero_Menor_al_Mayor_En_Pila(obj_Pila_A_Insertar_Numero,
numero):
obj_Numeros_Mayores_Pila = Pila()
#Si se ingresa mas de 1 numero entro aqui
if (not obj_Pila_A_Insertar_Numero.pila_vacia()):
#Si es mayor lo inserto de una
if (numero >= obj_Pila_A_Insertar_Numero.elemento_cima()):
obj_Pila_A_Insertar_Numero.apilar(numero)
else:
# Evaluo todos los menores al numero incluyendo los iguales y los apilo
# En la pila auxiliar obj_Numeros_Mayores_Pila
# Despues cuando se rompa el bucle doy por hecho que llego a que
# Numero es mayor al elemento de la cima o que no encontro ninguno
while ((not obj_Pila_A_Insertar_Numero.pila_vacia())
and (numero < obj_Pila_A_Insertar_Numero.elemento_cima())):
elemento = obj_Pila_A_Insertar_Numero.desapilar()
obj_Numeros_Mayores_Pila.apilar(elemento)
obj_Pila_A_Insertar_Numero.apilar(numero)
#Coloco todos los numeros que eran mayores al numero ingresado
while (not obj_Numeros_Mayores_Pila.pila_vacia()):
obj_Pila_A_Insertar_Numero.apilar(
obj_Numeros_Mayores_Pila.desapilar())
else:
#Si no hay nada le inserto el primer numero esto para cuando se hace el primer bucle
obj_Pila_A_Insertar_Numero.apilar(numero)
def invertir_Pila(pila_a_invertir):
aux_Pila = Pila()
while (not pila_a_invertir.pila_vacia()):
aux_Pila.apilar(pila_a_invertir.desapilar())
return aux_Pila
def apilarGenero(cola, genero):
pila = Pila()
while (cola.es_vacia() != True):
pelicula = cola.desencolar()
if (pelicula.genero == genero):
pila.apilar(pelicula)
return pila
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 guardar_estados_clave(estados,angulo):
"""Devuelve una cola con los estados clave (de inflexión) que definen dibujo"""
pluma = Pluma()
tortuga = Tortuga(pluma)
estados_clave = Cola()
pila_tortugas = Pila()
encolar_estado_clave(tortuga, estados_clave) #guarda la posición [0,0] con orientación 0 y pluma = True como "inicio"
for _ in range(len(estados.items)):
accion = estados.desencolar()
if not str(accion).isdigit():
if type(accion) == bool:
tortuga.pluma.cambiar_estado()
elif accion == '+':
tortuga.derecha(angulo)
elif accion == '-':
tortuga.izquierda(angulo)
elif accion == '|':
tortuga.orientacion += radians(180)
elif accion == '[':
tortuga = apilar_tortuga(tortuga, pila_tortugas)
elif accion == ']':
encolar_estado_clave(tortuga, estados_clave)
estados_clave.encolar(CAMBIO_DE_TORTUGA)
tortuga = desapilar_tortuga(tortuga, pila_tortugas)
encolar_estado_clave(tortuga, estados_clave)
else:
tortuga.adelante(accion)
encolar_estado_clave(tortuga, estados_clave)
return estados_clave
def postorden(cadena): save="" if cadena is not None: pila=Pila() print "la operacion a efectuar es: "+cadena.operacion for c in cadena.operacion: if c =="*": A=int(pila.pop().valor) B=int(pila.pop().valor) C=A*B print " se multiplico "+str(B)+" por "+str(A) pila.push(str(C)) elif c =="+": A=int(pila.pop().valor) B=int(pila.pop().valor) C=A+B print " se sumo "+str(B)+" mas "+str(A) pila.push(str(C)) elif c =="-": A=int(pila.pop().valor) B=int(pila.pop().valor) C=B-A print " se resto "+str(B)+" menos "+str(A) pila.push(str(C)) elif c=="0" or c=="1" or c=="2" or c=="3" or c=="4" or c=="5" or c=="6" or c=="7" or c=="8" or c=="9" : save=save+c print " se cargo "+c+" a la pila " else: if save!="": pila.push(save) save="" print "resultado="+pila.pop().valor else: print "la cola parece estar vacia"
def analizar_secuencia(instrucciones, codificaciones):
""" Recibe un string con instrucciones y un diccionario que contiene la codificación para algunas instrucciones variables.
Devuelve un set de trazos correspondientes al análisis del string, la distancia máxima y la distancia mínima con la que ha de crearse
el svg.
"""
coordenada_min = Vector()
coordenada_max = Vector()
pila_de_tortugas = Pila()
pila_de_tortugas.apilar(Tortuga())
tortuga_tope = pila_de_tortugas.ver_tope()
profundidad = len(pila_de_tortugas)
trazos = set()
for c in instrucciones:
if c == "[":
nueva_tortuga = tortuga_tope.clonar()
pila_de_tortugas.apilar(nueva_tortuga)
tortuga_tope = pila_de_tortugas.ver_tope()
profundidad = len(pila_de_tortugas)
elif c == "]":
pila_de_tortugas.desapilar()
tortuga_tope = pila_de_tortugas.ver_tope()
profundidad = len(pila_de_tortugas)
elif c == "F":
ultima_posicion = tortuga_tope.conseguir_posicion()
tortuga_tope.avanzar(DISTANCIA_BASE *
(FACTOR_EXPANSION**profundidad))
nueva_posicion = tortuga_tope.conseguir_posicion()
coordenada_min = calcular_min(coordenada_min, nueva_posicion)
coordenada_max = calcular_max(coordenada_max, nueva_posicion)
nuevo_trazo = Trazo(ultima_posicion, nueva_posicion,
tortuga_tope.conseguir_grosor(),
tortuga_tope.conseguir_color())
trazos.add(nuevo_trazo)
elif c == "f":
tortuga_tope.levantar_pluma()
tortuga_tope.avanzar(DISTANCIA_BASE *
(FACTOR_EXPANSION**profundidad))
tortuga_tope.bajar_pluma()
elif c in "+-|":
tortuga_tope.girar(codificaciones[c])
elif c in COLORS:
tortuga_tope.cambiar_color_pluma(COLORS[c])
elif c in "0123456789":
print(c)
tortuga_tope.cambiar_grosor_pluma(c)
return trazos, coordenada_min + Vector(-50, -50), coordenada_max + Vector(
50, 50)
def ejercicio_3():
obj_Pila = Pila()
for i in range(0, 100):
num = randint(1, 10)
obj_Pila.apilar(num)
obj_Pila = sacar_Ocurrencias_De_La_Pila(obj_Pila)
def ejercicio_5():
obj_Pila = Pila()
palabra = input('Ingrese una palabra: ')
for letra in palabra:
obj_Pila.apilar(letra)
print(es_Palindromo(obj_Pila))
def test_push(self):
"Chequea que el elemento pusheado sea efectivamente el tope de la pila"
y="2"
x=1
pila1=Pila()
pila1.push(x)
pila1.push(y)
self.assertEqual(pila1.body[0],y)
def orden_topologico_dfs(grafo):
"""Retorna una lista con un orden topologico posible.
En caso de hallar un ciclo, retorna None."""
visitados = set()
pila = Pila()
for v in grafo.obtener_todos_los_vertices():
if v not in visitados:
orden_topologico_recursivo(grafo, v, pila, visitados)
return pila
def test_array(self):
"Chequea que el array de la pila solo puede tener listas"
pila1 = Pila()
pila1.body="aaaa"
self.assertTrue(type(pila1.body)==list)
pila1.body=(1,2,3)
self.assertTrue(type(pila1.body)==list)
pila1.body=[1,2,3]
self.assertTrue(type(pila1.body)==list)
def __init__(self):
self.constante_entero = []
self.constante_flotante = []
self.constante_str = []
self.apuntador = Pila()
self.globales = Memoria()
self.main = Memoria()
self.alcanceActual = 0
self.funciones = dict()
def ejercicio_4():
obj_Pila = Pila()
for i in range(0, 20):
num = randint(1, 10)
obj_Pila.apilar(num)
obj_Pila.apilar(102)
obj_Pila = invertir_Pila(obj_Pila)
def __init__(self,size):
self.pila = Pila()
self.pila.push('$')
self.pila.push('0')
self.columna = 0
self.cantidad = size
self.accion = ""
self.list_tmp = list()
self.arbol = []
