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 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 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 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 apilarGenero(cola, genero): pila = Pila() while (cola.es_vacia() != True): pelicula = cola.desencolar() if (pelicula.genero == genero): pila.apilar(pelicula) return 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 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 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 main(): libros = Pila() for datos in readFile('libros.csv'): libros.apilar(Libro(datos[0], datos[1], datos[2])) print(libros.items) print(len(libros.items)) print(buscar(libros, 'Anna Llenas')) print(len(libros.items))
def sacar_Impares_De_Pila(datos_pila): aux_Pila = Pila() while (not datos_pila.pila_vacia()): elemento = datos_pila.desapilar() if (elemento % 2 == 0): aux_Pila.apilar(elemento) return aux_Pila
def ejercicio_1(): obj_pila = Pila() for i in range(0, 100): num = randint(1, 10) obj_pila.apilar(num) numero = int(input('ingrese un numero: ')) print(retornar_Numero_De_Ocurrencias(obj_pila, numero))
def generar_lista_partes(): """"No recibe nada. Devuelve una lista de partes random""" partes = {} for tipo_parte in TIPOS_PARTE: pila_tipo_parte = Pila() for _ in range(CANTIDAD_PARTES): parte = Parte(tipo_parte) agregar_armas_parte(parte) pila_tipo_parte.apilar(parte) partes[tipo_parte] = pila_tipo_parte return partes
def movimientos_pista(estado): '''Apila los movimientos de la solucion''' pistas = Pila() try: resuelto, solucion = buscar_solucion(estado) except: return pistas if resuelto: for movimiento in solucion: pistas.apilar(movimiento) return pistas
def ejercicio_2(): obj_Pila = Pila() for i in range(0, 100): num = randint(1, 10) obj_Pila.apilar(num) obj_Pila = sacar_Impares_De_Pila(obj_Pila) for i in range(0, obj_Pila.tamanio()): print(obj_Pila.desapilar())
def generar_lista_armas(): """Devuelve una lista de armas random.""" armas={} tipos_arma=(Arma.MELEE,Arma.RANGO) tipos_municion=(Arma.MUNICION_FISICA,Arma.MUNICION_HADRON,Arma.MUNICION_LASER) for tipo_arma in tipos_arma: pila_tipo_arma=Pila() for _ in range(CANTIDAD_DE_ARMAS): pila_tipo_arma.apilar(Arma(random.choice(CLASES_ARMA),tipo_arma,random.choice(tipos_municion))) armas[tipo_arma]=pila_tipo_arma return armas
def sacar_Ocurrencias_De_La_Pila(datos_pila): aux_Pila = Pila() aux_Conjunto = list() while (not datos_pila.pila_vacia()): elemento = datos_pila.desapilar() if (not (elemento in aux_Pila)): aux_Conjunto.append(elemento) aux_Pila.apilar(elemento) return aux_Pila
def calculadora_polaca(elementos): """ Dada una lista de elementos que representan las componentes de una expresion en notacion polaca inversa, evalua dicha expresion. Si la expresion esta mal formada, levanta ValueError """ p = Pila() for elemento in elementos: print(f"\nDEBUG: entra {elemento}") # Intenta convertirlo a numero try: numero = float(elemento) p.apilar(numero) print(f"DEBUG: apila {numero}") # si no se puede convertir, deberia ser un operando except ValueError: if elemento not in ('+', '-', '/', '*'): raise ValueError("Operando inválido") # Si es un operando válido, intenta desapilar y operar try: a1 = p.desapilar() print(f"\nDEBUG: desapila {a1}") a2 = p.desapilar() print(f"\nDEBUG: desapila {a2}") except IndexError: raise ValueError("Faltan operandos..") if elemento == "+": resultado = a2 + a1 if elemento == "-": resultado = a2 - a1 if elemento == "/": resultado = a2 / a1 if elemento == "*": resultado = a2 * a1 print(f"\nDEBUG: apila {resultado}") p.apilar(resultado) # Al final el resultado debe ser lo unico en la pila resultado = p.desapilar() if not p.esta_vacia(): raise ValueError("Sobran operandos") return resultado
def _min_seguimientos(grafo, origen, destino): distancia, padre = biblioteca.camino_minimo_bfs(grafo, origen, destino) if destino not in distancia: return None p = Pila() aux = destino while aux != origen: p.apilar(aux) aux = padre[aux] p.apilar(origen) camino = [] while not p.esta_vacia(): camino.append(p.desapilar()) return camino
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 get_Dinero_Total(obj_Pila): obj_Aux_Pila = Pila() Vector = None total = 0.0 while (not obj_Pila.pila_vacia()): Vector = obj_Pila.desapilar() obj_Aux_Pila.apilar(Vector) total += Vector[1] while (not obj_Aux_Pila.pila_vacia()): obj_Pila.apilar(obj_Aux_Pila.desapilar()) return total
def get_Total_Personas_Capturadas(obj_Pila): obj_Aux_Pila = Pila() contador = 0 while (not obj_Pila.pila_vacia()): obj_Aux_Pila.apilar(obj_Pila.desapilar()) if (obj_Aux_Pila.elemento_cima()[2] != 'Fallo'): contador += 1 while (not obj_Aux_Pila.pila_vacia()): obj_Pila.apilar(obj_Aux_Pila.desapilar()) return contador
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 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 get_Numero_Mision_Boba_Capturo_A_Han(obj_Pila): obj_Aux_Pila = Pila() Vector = None Mision = 1 while ((not obj_Pila.pila_vacia()) and (obj_Pila.elemento_cima()[2] != 'Han Solo')): Mision += 1 Vector = obj_Pila.desapilar() obj_Aux_Pila.apilar(Vector) while (not obj_Aux_Pila.pila_vacia()): obj_Pila.apilar(obj_Aux_Pila.desapilar()) return Mision
def get_Cantidad_Peliculas_En_La_Que_Aparece_Black_Widow(obj_Pila): obj_Aux_Pila = Pila() cant_peliculas = 0 while ((not obj_Pila.pila_vacia()) and (obj_Pila.elemento_cima()[0] != 'Black Widow')): obj_Aux_Pila.apilar(obj_Pila.desapilar()) if (obj_Pila.elemento_cima()[0] == 'Black Widow'): cant_peliculas = len(obj_Pila.elemento_cima()) - 1 while (not obj_Aux_Pila.pila_vacia()): obj_Pila.apilar(obj_Aux_Pila.desapilar()) return cant_peliculas
def reemplazar(pila, valor_nuevo, valor_viejo): pila_aux = Pila() while not pila.esta_vacia(): elemento = pila.desapilar() if elemento == valor_viejo: elemento = valor_nuevo pila_aux.apilar(elemento) while not pila_aux.esta_vacia(): pila.apilar(pila_aux.desapilar())
def get_Nombres_Que_Empiezan_Con_C_D_And_G(obj_Pila): obj_Aux_Pila = Pila() indice = 0 Vector = [] while (not obj_Pila.pila_vacia()): obj_Aux_Pila.apilar(obj_Pila.desapilar()) if (obj_Aux_Pila.elemento_cima()[0][0] in ['C', 'D', 'G']): Vector.insert(indice, obj_Aux_Pila.elemento_cima()[0]) indice += 1 while (not obj_Aux_Pila.pila_vacia()): obj_Pila.apilar(obj_Aux_Pila.desapilar()) return Vector
def es_Palindromo(palabra): obj_Cola = Cola() obj_Pila = Pila() letra = None for i in range(0, len(palabra)): letra = palabra[i].lower() obj_Cola.arribo(letra) obj_Pila.apilar(letra) mitad = len(palabra)//2 for i in range(0, mitad): if(obj_Pila.desapilar() != obj_Cola.atencion()): return False return True
class ColaDeReproduccion: """Clase que representa la cola de reproduccion del reproductor. Permite agregar y remover canciones, ademas de poder hacer y deshacer estas acciones. Las canciones se guardan en la cola como objetos de clase Cancion.""" AGREGADA = 1 REMOVIDA = 0 def __init__(self, lista_canciones=[]): """ Recibe una lista de objetos de clase Cancion con las canciones que se quieren reproducir.""" lista = ListaEnlazada() for cancion in lista_canciones: lista.insert(cancion) self.lista_canciones = lista self.acciones_tomadas = Pila() self.acciones_deshechas = Pila() self.actual = 0 def cancion_actual(self): """ Devuelve un objeto de clase Cancion que corresponde a la cancion actual, o None si no hay canciones cargadas en la cola.""" if self.lista_canciones.esta_vacia(): return None try: cancion = self.lista_canciones.get_elemento(self.actual) except IndexError: return return cancion def cancion_siguiente(self): """ Devuelve un objeto de clase Cancion que corresponde a la cancion siguiente en la cola, o None si no hay mas canciones.""" if len(self.lista_canciones) < 1: return None try: cancion = self.lista_canciones.get_elemento(self.actual + 1) self.actual += 1 except IndexError: return return cancion def cancion_anterior(self): """ Devuelve un objeto de clase Cancion que corresponde a la cancion anterior en la cola, o None si no hay canciones en la misma o la actual es la primera de la cola.""" if len(self.lista_canciones) < 1: return None try: cancion = self.lista_canciones.get_elemento(self.actual - 1) self.actual -= 1 except IndexError: #No hay cancion anterior return return cancion def agregar_cancion(self, ruta_cancion): """ Agrega una Cancion a la cola a partir de su ruta. Devuelve True si se agrego correctamente, False en caso contrario. Esta accion puede deshacerse y rehacerse.""" try: self.agregar_cancion_sin_guardar(ruta_cancion) self.guardar_accion(ruta_cancion, self.AGREGADA) return True except (TinyTagException, LookupError, OSError): return False def remover_cancion(self, ruta_cancion): """ Remueve una Cancion de la cola a partir de su ruta. Devuelve True si se removio correctamente, False en caso contrario. Esta accion puede deshacerse y rehacerse.""" try: resultado = self.remover_cancion_sin_guardar(ruta_cancion) self.guardar_accion(ruta_cancion, self.REMOVIDA) return resultado except (TinyTagException, LookupError, OSError): return False def deshacer_modificacion(self): """ Deshace la ultima accion realizada. Devuelve True si pudo deshacerse, False en caso contrario.""" try: ruta_ultima_cancion, ultima_accion = self.acciones_tomadas.desapilar() if ultima_accion == self.AGREGADA: self.remover_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_deshechas.apilar((ruta_ultima_cancion, self.AGREGADA)) return True self.agregar_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_deshechas.apilar((ruta_ultima_cancion, self.REMOVIDA)) return True except (ValueError, IndexError): return False def rehacer_modificacion(self): """ Rehace la ultima accion que se deshizo. Devuelve True si pudo rehacerse, False en caso contrario.""" try: ruta_ultima_cancion, ultima_accion = self.acciones_deshechas.desapilar() if ultima_accion == self.AGREGADA: self.agregar_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_tomadas.apilar((ruta_ultima_cancion, self.AGREGADA)) return True self.remover_cancion_sin_guardar(ruta_ultima_cancion) self.acciones_tomadas.apilar((ruta_ultima_cancion, self.REMOVIDA)) return True except (ValueError, IndexError): return False def obtener_n_siguientes(self, n_canciones): """ Devuelve una lista con las siguientes n canciones. Si en la cola de reproduccion quedan menos canciones que las pedidas, la lista contendra menos elementos que los pedidos.""" if self.lista_canciones.esta_vacia(): return None lista = [] for i in range(n_canciones): try: lista.append(self.lista_canciones.get_elemento(self.actual + 1 + i)) except IndexError: return lista return lista def __str__(self): return str(self.lista_canciones) def guardar_accion(self, ruta_cancion, accion): """Guarda la accion como una tupla (ruta_cancion, accion).""" self.acciones_tomadas.apilar((ruta_cancion, accion)) def agregar_cancion_sin_guardar(self, ruta_cancion): """Agrega la cancion a la lista de reproduccion.""" cancion = Cancion(ruta_cancion) self.lista_canciones.insert(cancion) def remover_cancion_sin_guardar(self, ruta_cancion): """Remueve la cancion de la lista de reproduccion. Devuelve True en caso que sea exitoso y False en caso contrario.""" cancion = Cancion(ruta_cancion) posicion = self.lista_canciones.index(cancion) if posicion: self.lista_canciones.pop(posicion) return True return False