def ejercicio_11(): obj_Cola = Cola() Mat_PJ_de_SW = [ ['Chewbacca', 'Anoat'], ['Obi-Wan Kenobi', 'Tatooine'], ['Yoda','Endor'], ['BB8', 'Alderaan'], ['Padme Amidala','Atollon'], ['Luke Skywalker', 'Tatooine'], ['Han Solo','Corellia'], ['Jar Jar Binks', 'Anoat'] ] for datos_PJ in Mat_PJ_de_SW: obj_Cola.arribo(datos_PJ) print('\nMOSTRAR PERSONAJE CON SU PLANETA DE ORIGEN\n') mostrar_Pj_De_Star_Wars_Con_Su_Planeta(get_Pj_De_Los_Planetas_Alderaan_Endor_Tatooine(obj_Cola)) print('\nPLANETA DE LUKE Y HAN\n') mostrar_Planeta_Natal_De_Luke_Y_Han_Solo(get_Planeta_Natal_De_Luke_Y_Han_Solo(obj_Cola)) print('\nINSERTAR PERSONAJE ANTES QUE YODA\n') insertar_Personaje_Antes_Que_Yoda(obj_Cola) imprimir_Cola(obj_Cola) print('\nELIMINAR PERSONAJE DESPUES DE JAR JAR BINKS\n') eliminar_Personaje_Despues_De_Jar_Jar_Binks(obj_Cola) imprimir_Cola(obj_Cola)
def parser(cadena, user): try: full_file = os.path.abspath(os.path.join(cadena)) dom = ElementTree.parse(full_file) if user.mat == None: ejex = dom.find('matriz/x').text ejey = dom.find('matriz/y').text matriz = Matriz() matriz.crear(ejey, ejex) user.mat = matriz trans = Matriz() trans.crear(ejex, ejey) user.trans = trans cola = Cola() operacion = dom.findall('operaciones/operacion') if user.cola == None: for op in operacion: cola.queque(op.text) user.cola = cola else: for op in operacion: user.cola.queque(op.text) print "----------cargado exitosamente----------" except IOError: print "este archivo no existe en esta carpeta" return user
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
class TorreDeControl: def __init__(self): self.arribos = Cola() self.partidas = Cola() def nuevo_arribo(self,avion): self.arribos.encolar(avion) def nueva_partida(self,avion): self.partidas.encolar(avion) def ver_estado(self): print(f'Vuelos esperando para aterrizar: {str(self.arribos)}\nVuelos esperando para despegar: {str(self.partidas)}') def asignar_pista(self): try: print(f'El vuelo {self.arribos.desencolar()} aterrizó con éxito') except ValueError: try: print(f'El vuelo {self.partidas.desencolar()} despegó con éxito') except ValueError: print('No hay vuelos en espera')
def main(): a = Cola() for i in range(0, 10): a.encolar((int)(1 + random() * 20)) a.imprimir() a.desencolar() a.imprimir()
def main(): cupos = randrange(1, 10) parqueaderos = Cola() horarios = [ Horario(1, 6, 13), Horario(2, 6, 15), Horario(3, 8, 12), Horario(4, 9, 16) ] motos = [ Moto("EPF123", "verde", 3), Moto("EXF123", "azul", 3), Moto("EPQ123", "negra", 3), Moto("QEF123", "blanca", 3), Moto("LHJ123", "rosada", 3), Moto("POI123", "gris", 3) ] estudiantes = [ Estudiante(20112020005, "Felipe Duitama", 1, 1), Estudiante(20112020005, "Felipe Duitama", 2, 2), Estudiante(20112020005, "Felipe Duitama", 3, 3), Estudiante(20112020005, "Felipe Duitama", 4, 4), Estudiante(20112020005, "Felipe Duitama", 1, 5), ] if len(parqueaderos.items) < cupos: estudiante = choice(estudiantes) parqueaderos.encolar(estudiante) estudiantes.remove(estudiante) print(parqueaderos.items)
def inicializacion(self, duracion_simulacion): super(Simulacion2mec, self).inicializacion(duracion_simulacion) self.estado_mecanico = [Simulacion.DESOCUPADO, Simulacion.DESOCUPADO] self.cola_mecanico = [Cola('mecanico'), Cola('mecanico')] # Lista de eventos self.lista_de_eventos = { 'arribo_pala': [ Evento('arribo_pala'), Evento('arribo_pala'), Evento('arribo_pala') ], 'partida_pala': [ Evento('partida_pala'), Evento('partida_pala'), Evento('partida_pala') ], 'arribo_aplastador': Evento('arribo_aplastador'), 'partida_aplastador': Evento('partida_aplastador'), 'fin_de_reparacion': [Evento('fin_de_reparacion'), Evento('fin_de_reparacion')] }
def ejercicio_22(): obj_Cola = Cola() array_Personajes_MCU = [ ['Tony Stark', 'Iron Man', 'M'], ['Thor Odinson', 'Thor', 'M'], ['Carol Danvers','Capitana Marvel','F'], ['Steve Rogers', 'Capitan America', 'M'], ['Scott Lang', 'Hombre Hormiga', 'F'], ['Stephen Strange', 'Doctor Strange', 'M'], ] for i in range(0, len(array_Personajes_MCU)): obj_Cola.arribo(array_Personajes_MCU[i]) print('NOMBRE DE CAPITANA MARVEL') print(get_Mensaje_Si_Existe_Personaje_O_Super_Heroe(get_Nombre_Personaje(obj_Cola, 'Capitana Marvel'), 'Capitana Marvel')) print('\nSUPER HEROINAS') print(get_Personajes_Concatenados_De_Un_Vector(get_Super_Heroinas(obj_Cola))) print('PERSONAJES MASCULINOS') print(get_Personajes_Concatenados_De_Un_Vector(get_Personajes_Masculinos(obj_Cola))) print('NOMBRE DE SUPER HEROE DE SCOTT LANG') print(get_Mensaje_Si_Existe_Personaje_O_Super_Heroe(get_Nombre_Del_Super_Heroe(obj_Cola, 'Scott Lang'), 'Scott Lang')) print('\nPERSONAJES Y SUPER HEROES CON INICIAL S') print(get_Personajes_Concatenados_De_Una_Matriz(get_Nombres_Con_S(obj_Cola))) print('NOMBRE DE SUPER HEROE DE CAROL DANVERS') print(get_Mensaje_Si_Existe_Personaje_O_Super_Heroe(get_Nombre_Del_Super_Heroe(obj_Cola, 'Carol Danvers'), 'Carol Danvers'))
def inicializacion(self, duracion_simulacion): super(SimulacionUnaCola, self).inicializacion(duracion_simulacion) self.cola_pala = Cola('pala') for i in range(3): self.cola_pala.agregar(Camion(50)) for k in range(2): self.cola_pala.agregar(Camion(20)) # Lista de eventos self.lista_de_eventos = { 'arribo_pala': Evento('arribo_pala'), 'partida_pala': [ Evento('partida_pala'), Evento('partida_pala'), Evento('partida_pala') ], 'arribo_aplastador': Evento('arribo_aplastador'), 'partida_aplastador': Evento('partida_aplastador'), 'fin_de_reparacion': Evento('fin_de_reparacion') }
def ejercicio_6(): obj_Cola = Cola() for i in range(0, 15): obj_Cola.arribo(randint(1, 10)) numero = int(input('ingrese un numero: ')) print('Cantidad de ocurrencias: ', contar_Ocurrencias(obj_Cola, numero))
def barrido_por_nivel_huff(self): pendientes = Cola() pendientes.arribo(self) while(not pendientes.cola_vacia()): nodo = pendientes.atencion() print(nodo.info, nodo.frecuencia) if(nodo.izq is not None): pendientes.arribo(nodo.izq) if(nodo.der is not None): pendientes.arribo(nodo.der)
def barrido_por_nivel_huff(self): """Realiza el barrido por nivel del arbol con codigos de Huffman.""" pendientes = Cola() pendientes.arribo(self) while (not pendientes.cola_vacia()): nodo = pendientes.atencion() print(nodo.info, nodo.datos) if (nodo.izq is not None): pendientes.arribo(nodo.izq) if (nodo.der is not None): pendientes.arribo(nodo.der)
def barrido_por_nivel(self): """Realiza el barrido por nivel del arbol.""" pendientes = Cola() pendientes.arribo(self) while (not pendientes.cola_vacia()): nodo = pendientes.atencion() print(nodo.info) if (nodo.izq is not None): pendientes.arribo(nodo.izq) if (nodo.der is not None): pendientes.arribo(nodo.der)
def encolar_personas_enlistas_colectivos(lista_eventos): personas = Cola() colectivos = [] for evento in lista_eventos: if evento[1] == 'p': personas.encolar(evento) else: colectivos.append(evento) return personas, colectivos
def orden_topologico(grafo): res = [] orden = {} visitados = set() for v in grafo.obt_vertices(): orden[v] = 0 for v in grafo.obt_vertices(): for w in grafo.obtener_vecinos(v): orden[w] += 1 cola = Cola() for v, grado in orden.items(): if grado == 0: cola.encolar(v) while (not cola.esta_vacia()): v = cola.desencolar() if v in visitados: continue res.append(v) visitados.add(v) for w in grafo.obtener_vecinos(v): orden[w] -= 1 for v, grado in orden.items(): if grado == 0: cola.encolar(v) return res
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
def invertir_Cola(contenedor): obj_Cola = Cola() obj_Pila = Pila() for i in range(0, len(contenedor)): obj_Cola.arribo(contenedor[i]) while(not obj_Cola.cola_vacia()): obj_Pila.apilar(obj_Cola.atencion()) while(not obj_Pila.pila_vacia()): obj_Cola.arribo(obj_Pila.desapilar()) for i in range(0, obj_Cola.tamanio()): contenedor[i] = obj_Cola.atencion() return contenedor
def inicializacion(self, duracion_simulacion): self.duracion_simulacion = duracion_simulacion # Contadores Estadisticos self.tiempo_ocioso = 0 self.total_material_transportado = 0 self.total_descomposturas = 0 self.acrt = 0 # Variables de estado self.reloj_simulacion = 0 self.estado_pala = [ Simulacion.DESOCUPADO, Simulacion.DESOCUPADO, Simulacion.DESOCUPADO ] self.estado_aplastador = Simulacion.DESOCUPADO self.estado_mecanico = Simulacion.DESOCUPADO self.ult_ubicacion_mecanico = 'pala' self.ultima_medicion_descomposturas = 0 self.dcrt = 0 self.colas_pala = [] for i in range(3): cola_pala = Cola('pala') cola_pala.agregar(Camion(50, i)) cola_pala.agregar(Camion(20, i)) cola_pala.agregar(Camion(20, i)) self.colas_pala.append(cola_pala) self.cola_aplastador = Cola('aplastador') self.cola_mecanico = Cola('mecanico') # Lista de eventos self.lista_de_eventos = { 'arribo_pala': [ Evento('arribo_pala'), Evento('arribo_pala'), Evento('arribo_pala') ], 'partida_pala': [ Evento('partida_pala'), Evento('partida_pala'), Evento('partida_pala') ], 'arribo_aplastador': Evento('arribo_aplastador'), 'partida_aplastador': Evento('partida_aplastador'), 'fin_de_reparacion': Evento('fin_de_reparacion') }
def test(self): cola = Cola() #Define medico y cola cola.enqueue("Pedro")# Ingresa un paciente en la cola de Pablo cola.enqueue("Marco")# Ingresa un paciente en la cola de Pablo self.agregarMedico("Pablo", cola) #Ingresa a pablo y su cola de pacientes mCola = self.dict["Pablo"] #Saca cola de pacienes de pablo print(mCola.dequeue())#saca el siguiente paciente en la cola print(mCola.dequeue())#saca el siguiente paciente en la cola cola1 = Cola() #// cola1.enqueue("P") cola1.enqueue("M") self.agregarCola("Jose", cola1) mCola = self.dict["Jose"] # // print(mCola.dequeue()) print(mCola.dequeue())
def topologico_grados(grafo): g_ent = grados_entrada(grafo) q = Cola() for v in grafo: if g_ent[v] == 0: q.encolar(v) resultado = [] while not q.esta_vacia(): v = q.desencolar() resultado.append(v) for w in grafo.adyacentes(v): g_ent[w] -= 1 if g_ent[w] == 0: q.encolar(w) return resultado
def distancias_ady(grafo, origen, visitados, orden, dicc_dist): q = Cola() q.encolar(origen) visitados[origen] = True while not q.esta_vacia(): v = q.desencolar() ady = list(grafo.adyacentes(v)) for w in ady: if w not in visitados: visitados[w] = True orden[w] = orden[v] + 1 if not orden[w] in dicc_dist: dicc_dist[orden[w]] = 1 else: dicc_dist[orden[w]] += 1 q.encolar(w)
class Impresora: def __init__(self, nombre, capacidad_tinta): self.nombre = nombre self.capacidad_max = capacidad_tinta self.capacidad = self.capacidad_max self.cola_de_impresion = Cola() def encolar(self,archivo): self.cola_de_impresion.encolar(archivo) def imprimir(self): if not self.capacidad: print('No tengo tinta :(') return print(f'{self.cola_de_impresion.desencolar()} impreso.') self.capacidad -= 1 def cargar_tinta(self): self.capacidad = self.capacidad_max
def camino_minimo(grafo, origen): visitados = set() distancia = {} padre = {} padre[origen] = None distancia[origen] = 0 q = Cola() q.encolar(origen) visitados.add(origen) while not q.esta_vacia(): v = q.desencolar() for w in grafo.adyacentes(v): if not w in visitados: padre[w] = v distancia[w] = distancia[v] + 1 visitados.add(w) q.encolar(w) return distancia, padre
def bfs(grafo, inicio): if not grafo.vertice_esta(inicio): return None cola = Cola() visitados = set() padres = {} padres[inicio] = None visitados.add(inicio) cola.encolar(inicio) while (not cola.esta_vacia()): vertice = cola.desencolar() for v in grafo.obtener_vecinos(vertice): if v in visitados: continue visitados.add(v) padres[v] = vertice cola.encolar(v) return padres
def bfs(grafo, origen): visitados = set() padres = {} orden = {} padres[origen] = None orden[origen] = 0 visitados.add(origen) q = Cola() # usar deque de collections, NO QUEUE!! q.encolar(origen) while not q.esta_vacia(): v = q.desencolar() for w in grafo.adyacentes(v): # E1 + E2 + E3 + ... + Ev = k E if w not in visitados: padres[w] = v orden[w] = orden[v] + 1 visitados.add(w) q.encolar(w) # O(V + E) return padres, orden
def divulgar(grafo, args): origen = args[0] n = int(args[1]) resultado = [] visitados = set() orden = {} orden[origen] = 0 q = Cola() q.encolar(origen) visitados.add(origen) while not q.esta_vacia(): v = q.desencolar() for w in grafo.adyacentes(v): if not w in visitados: orden[w] = orden[v] + 1 if orden[w] > n: print(*resultado, sep=", ") return resultado.append(w) visitados.add(w) q.encolar(w)
def orden_topologico(grafo): """Solo funciona para grafo dirigido""" resultado = [] cola = Cola() orden = {} for v in grafo.obtener_todos_vertices(): orden[v] = 0 for v in grafo.obtener_todos_vertices(): for w in grafo.adyacentes_vertice(v): orden[w] += 1 for v in grafo.obtener_todos_vertices(): if (orden[v] == 0): cola.encolar(v) while not cola.esta_vacia(): v = cola.desencolar() resultado.append(v) for w in grafo.adyacentes_vertice(v): orden[w] -= 1 if orden[w] == 0: cola.encolar(w) return resultado
def barrido_amplitud(self, ver_origen): cola = Cola() while (ver_origen < self.tamanio()): vertice = self.inicio.obtener_elemento(ver_origen) if (not vertice['visitado']): vertice['visitado'] = True cola.arribo(vertice) while (not cola.cola_vacia()): nodo = cola.atencion() print(nodo['info']) aristas = 0 while (aristas < nodo['aristas'].tamanio()): adyacente = nodo['aristas'].obtener_elemento(aristas) pos_vertice = self.buscar_vertice(adyacente['destino']) nuevo_vertice = self.inicio.obtener_elemento( pos_vertice) if (not nuevo_vertice['visitado']): nuevo_vertice['visitado'] = True cola.arribo(nuevo_vertice) aristas += 1 ver_origen += 1
def bfs(self, visitar=visitar_nulo, extra=None, inicio=None): '''Realiza un recorrido BFS dentro del grafo, aplicando la funcion pasada por parametro en cada vertice visitado. Parametros: - visitar: una funcion cuya firma sea del tipo: visitar(v, padre, orden, extra) -> Boolean Donde 'v' es el identificador del vertice actual, 'padre' el diccionario de padres actualizado hasta el momento, 'orden' el diccionario de ordenes del recorrido actualizado hasta el momento, y 'extra' un parametro extra que puede utilizar la funcion (cualquier elemento adicional que pueda servirle a la funcion a aplicar). La funcion aplicar devuelve True si se quiere continuar iterando, False en caso contrario. - extra: el parametro extra que se le pasara a la funcion 'visitar' - inicio: identificador del vertice que se usa como inicio. Si se indica un vertice, el recorrido se comenzara en dicho vertice, y solo se seguira hasta donde se pueda (no se seguira con los vertices que falten visitar) Salida: Tupla (padre, orden), donde : - 'padre' es un diccionario que indica para un identificador, cual es el identificador del vertice padre en el recorrido BFS (None si es el inicio) - 'orden' es un diccionario que indica para un identificador, cual es su orden en el recorrido BFS ''' if not inicio in self.vertices: raise KeyError (visitados, padre, orden) = crear_diccionarios(self.nombre_vertices) cola = Cola() cola.encolar(inicio) orden[inicio] = 0 while not cola.esta_vacia(): analizar = cola.desencolar() if not visitar(analizar, padre, orden, extra): return (padre, orden) dist = orden[analizar] if not visitados[analizar]: visitados[analizar] = True for adyacente in self.adyacentes(analizar): if orden[adyacente] == -1: orden[adyacente] = dist + 1 padre[adyacente] = analizar cola.encolar(adyacente) return (padre, orden)
def contar_personas(personas)): if personas.esta_vacia(): return 0 i = 1 cola_aux = Cola() while not personas.esta_vacia(): cola_aux.encolar(personas.desencolar()) i +=1 while not cola_aux.esta_vacia(): personas.encolar(cola_aux.desencolar()) return i
def bfs(self, visitar = visitar_nulo, extra = None, inicio=None): '''Realiza un recorrido BFS dentro del grafo, aplicando la funcion pasada por parametro en cada vertice visitado. Parametros: - visitar: una funcion cuya firma sea del tipo: visitar(v, padre, orden, extra) -> Boolean Donde 'v' es el identificador del vertice actual, 'padre' el diccionario de padres actualizado hasta el momento, 'orden' el diccionario de ordenes del recorrido actualizado hasta el momento, y 'extra' un parametro extra que puede utilizar la funcion (cualquier elemento adicional que pueda servirle a la funcion a aplicar). La funcion aplicar devuelve True si se quiere continuar iterando, False en caso contrario. - extra: el parametro extra que se le pasara a la funcion 'visitar' - inicio: identificador del vertice que se usa como inicio. Si se indica un vertice, el recorrido se comenzara en dicho vertice, y solo se seguira hasta donde se pueda (no se seguira con los vertices que falten visitar) Salida: Tupla (padre, orden), donde : - 'padre' es un diccionario que indica para un identificador, cual es el identificador del vertice padre en el recorrido BFS (None si es el inicio) - 'orden' es un diccionario que indica para un identificador, cual es su orden en el recorrido BFS ''' if not inicio in self.vertices: raise KeyError (visitados, padre, orden) = crear_diccionarios(self.nombre_vertices) cola = Cola() cola.encolar(inicio) orden[inicio] = 0 while not cola.esta_vacia(): analizar = cola.desencolar() if not visitar(analizar,padre,orden,extra): return (padre,orden) dist = orden[analizar] if not visitados[analizar]: visitados[analizar] = True for adyacente in self.adyacentes(analizar): if orden[adyacente] == -1: orden[adyacente] = dist + 1 padre[adyacente] = analizar cola.encolar(adyacente) return (padre,orden)
def setUp(self): self.cola = Cola() self.d1 = 'dummy1' self.d2 = 'dummy2' self.d3 = 'dummy3' self.d4 = 'dummy4'
class TestCola(unittest.TestCase): def setUp(self): self.cola = Cola() self.d1 = 'dummy1' self.d2 = 'dummy2' self.d3 = 'dummy3' self.d4 = 'dummy4' def test_inicio(self): self.assertIsInstance(self.cola._datos, ListaConPyLista) def test_poner(self): self.cola.poner(self.d1) expected = str([self.d1]) self.assertEqual(expected, str(self.cola)) self.cola.poner(self.d2) expected = str([self.d2, self.d1]) self.assertEqual(expected, str(self.cola)) self.cola.poner(self.d3) expected = str([self.d3, self.d2, self.d1]) self.assertEqual(expected, str(self.cola)) self.cola.poner(self.d4) expected = str([self.d4, self.d3, self.d2, self.d1]) self.assertEqual(expected, str(self.cola)) def test_sacar(self): self.cola.poner(self.d1) self.cola.poner(self.d2) self.cola.poner(self.d3) self.cola.poner(self.d4) self.assertEqual(self.d1, self.cola.sacar()) self.assertEqual(self.d2, self.cola.sacar()) self.assertEqual(self.d3, self.cola.sacar()) self.assertEqual(self.d4, self.cola.sacar()) self.assertRaises(IndexError, self.cola.sacar) def test_tope(self): self.cola.poner(self.d1) self.assertEqual(self.d1, self.cola.tope()) self.cola.poner(self.d2) self.assertEqual(self.d1, self.cola.tope()) self.cola.poner(self.d3) self.assertEqual(self.d1, self.cola.tope()) self.cola.poner(self.d4) self.assertEqual(self.d1, self.cola.tope()) def test_EsVacia_si(self): self.assertTrue(self.cola.esVacia()) self.cola.poner(self.d1) elem = self.cola.sacar() self.assertTrue(self.cola.esVacia()) def test_EsVacia_no(self): self.cola.poner(self.d1) self.assertFalse(self.cola.esVacia()) self.cola.poner(self.d2) self.assertFalse(self.cola.esVacia()) elem = self.cola.sacar() self.assertFalse(self.cola.esVacia())