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
Exemple #2
0
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():
    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)
Exemple #5
0
def main():
    a = Cola()
    for i in range(0, 10):
        a.encolar((int)(1 + random() * 20))
    a.imprimir()
    a.desencolar()
    a.imprimir()
Exemple #6
0
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
Exemple #7
0
    def contar_archivos(self, equipo):

        if equipo.cola_de_impresion.esta_vacia():
            return 0

        i = 1
        cola_aux = Cola()
        while not equipo.cola_de_impresion.esta_vacia():
            cola_aux.encolar(equipo.cola_de_impresion.desencolar())
            i +=1
        
        while not cola_aux.esta_vacia():
            equipo.cola_de_impresion.encolar(cola_aux.desencolar())

        return i
Exemple #8
0
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
Exemple #9
0
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
Exemple #10
0
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)
Exemple #11
0
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
Exemple #13
0
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
Exemple #14
0
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
Exemple #15
0
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)
Exemple #16
0
    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)
Exemple #17
0
 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)
Exemple #18
0
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
os.system(
    "C:\\Users\\santi\\OneDrive\\Desktop\\EDD_1S2019_P1_201313722\\graficaLD.png"
)

objP = Pila()
objP.apilar(10, 2)
objP.apilar(11, 3)
objP.apilar(12, 4)
objP.apilar(13, 5)
objP.graficarPila()
os.system(
    "dot C:\\Users\\santi\\OneDrive\\Desktop\\EDD_1S2019_P1_201313722\\graficaPila.dot -o C:\\Users\\santi\\OneDrive\\Desktop\\EDD_1S2019_P1_201313722\\graficaPila.png -Tpng -Gcharset=utf8"
)

fila = Cola()
fila.encolar("juan", 15)
fila.encolar("mario", 20)
fila.encolar("jennifer", 5)
fila.mostrar()
fila.desencolar()
fila.desencolar()
fila.desencolar()
fila.encolar("funciono", 100)
fila.mostrar()
fila.graficar()
os.system(
    "dot C:\\Users\\santi\\OneDrive\\Desktop\\EDD_1S2019_P1_201313722\\graficaCola.dot -o C:\\Users\\santi\\OneDrive\\Desktop\\EDD_1S2019_P1_201313722\\graficaCola.png -Tpng -Gcharset=utf8"
)
os.system(
    "C:\\Users\\santi\\OneDrive\\Desktop\\EDD_1S2019_P1_201313722\\graficaCola.png"
)
Exemple #20
0
import csv
from cola import Cola

datafile = open('infoLibros.csv', 'r')
datareader = csv.reader(datafile, delimiter=';')
data = Cola()

for row in datareader:
    data.encolar(row)

titulos = Cola()
for slist in data.items:
    titulos.encolar(slist[0])

autores = Cola()
for slist in data.items:
    autores.encolar(slist[1])

tematicas = Cola()
for slist in data.items:
    tematicas.encolar(slist[2])

paginas = Cola()
for slist in data.items:
    paginas.encolar(slist[3])

editoriales = Cola()
for slist in data.items:
    editoriales.encolar(slist[4])

res = Cola()
Exemple #21
0
def apilarGenero(cola, genero):
    pila = Pila()
    while (cola.es_vacia() != True):
        pelicula = cola.desencolar()
        if (pelicula.genero == genero):
            pila.apilar(pelicula)
    return pila


peliculas = [
    Pelicula("Terminator", "AC"),
    Pelicula("Misión Imposible", "AC"),
    Pelicula("La Ouija", "TR")
]

cola = Cola()

[cola.encolar(x) for x in peliculas]

genero = "AC"

print([x.nombre for x in cola.items])

pilaGenero = apilarGenero(cola, genero)

while (pilaGenero.es_vacia() != True):
    x = pilaGenero.desapilar()
    print(x.nombre + " " + x.genero)

#print ([x.nombre+" "+x.genero for x in pilaGenero.items])
]
[peliculas.apilar(x) for x in pelis]

#Se pide la entrada del genero que se desea obtener

print "Escriba el genero deseado para buscar peliculas del mismo tipo"
generoDeseado = raw_input()

#Se crea la cola de peliculas del genero seleccionado

seleccionadas = Cola()

while (peliculas.es_vacia() == False):
    pelicula16 = peliculas.desapilar()
    if (pelicula16.genero == generoDeseado):
        seleccionadas.encolar(pelicula16)

#Se le da a escoger al usuario la pelicula

escogida = False
contador = 0
while (seleccionadas.es_vacia() == False and escogida == False):
    contador = +contador + 1
    print "La pelicula #", contador, "del genero seleccionado es: ", seleccionadas.desencolar(
    ).nombre
    print "¿Esta es la deseada?, responda True si esta es, por el contrario responda False"
    escogida = input()
    if (seleccionadas.es_vacia() == True and escogida == False):
        print "No existen mas peliculas de este genero, lo sentimos"
    elif (escogida == True):
        print "Te felicitamos por encontrar el titulo que buscabas"
from pila import Pila

def ordenar_fases(fases):
    '''
    DOC: Completar
    '''
    ultimo = fases._ultimo.dato
    primer = fases.ver_frente()
    while not fases.esta_vacia():
        frente = fases.desencolar()
        ultimo_ordenado = fases._ultimo.dato if not frente == primer else 0
        if frente > ultimo_ordenado:
            print(frente)
            fases.encolar(frente)
            if frente == ultimo:
                break


fases = Cola()
fases.encolar(1)
fases.encolar(2)
fases.encolar(6)
fases.encolar(3)
fases.encolar(5)
fases.encolar(4)
fases.encolar(5)
fases.encolar(6)
fases.encolar(7)

ordenar_fases(fases)
Exemple #24
0
import csv
from cola import Cola
from pila import Pila

datafile = open('infoLibros.csv', 'r')
datareader = csv.reader(datafile, delimiter=';')
data = Cola()

for row in datareader:
    data.encolar(row)

#info = [list(i) for i in zip(*data)]

titulos = Cola()
for slist in data.items:
    titulos.encolar(slist[0])

autores = Cola()
for slist in data.items:
    autores.encolar(slist[1])

tematicas = Cola()
for slist in data.items:
    tematicas.encolar(slist[2])

paginas = Cola()
for slist in data.items:
    paginas.encolar(slist[3])

editoriales = Cola()
for slist in data.items:
Exemple #25
0
from cola import Cola


def cola_map(cola, f):
    nueva_cola = Cola()
    while not cola.esta_vacia():
        frente = cola.desencolar()
        nueva_cola.encolar(f(frente))
    return nueva_cola


c = Cola()
c.encolar(1)
c.encolar(2)
c.encolar(5)
c.encolar(3)
c.encolar(9)
c.encolar(4)

nueva_cola = cola_map(c, lambda x: x + 1)
while not nueva_cola.esta_vacia():
    print(nueva_cola.desencolar())
Exemple #26
0
def cola_map(cola, f):
    nueva_cola = Cola()
    while not cola.esta_vacia():
        frente = cola.desencolar()
        nueva_cola.encolar(f(frente))
    return nueva_cola
Exemple #27
0
import csv
from cola import Cola

archivo = open('Libros.csv', 'r')
lector = csv.reader(archivo, delimiter=';')
dato = Cola()

for x in lector:
    dato.encolar(x)

autores = Cola()
for slist in dato.items:
    autores.encolar(slist[1])

titulos = Cola()
for slist in dato.items:
    titulos.encolar(slist[0])

paginas = Cola()
for slist in dato.items:
    paginas.encolar(slist[3])

tematicas = Cola()
for slist in dato.items:
    tematicas.encolar(slist[2])

editoriales = Cola()
for slist in dato.items:
    editoriales.encolar(slist[4])

ordenAutor = Cola()
Exemple #28
0
def transcribir_secuencia(secuencia):
    """transcribe la secuencia de símbolos recibidos en forma de elementos significativos y los encola. Se devuelve una Cola al final.
    Los simbolos de avance (FG y fg) son acumulativos y se suman entre sí para dar una unidad -numero entero- de avance.
    Los cambios de pluma (fg) se encolan como "True" para "pluma abajo" y "False" para "pluma arriba".
    Los demás símbolos posibles se encolan como sí mismos"""

    estados = Cola()
    avance = 0
    pluma = True

    for accion in secuencia:

        if accion in 'FG':
            if not pluma:
                estados.encolar(avance)
                avance = 0
                pluma = True
                estados.encolar(pluma)
            avance += UNIDAD_DE_AVANCE
            continue

        elif accion in 'fg':

            if pluma:
                estados.encolar(avance)
                avance = 0
                pluma = False
                estados.encolar(pluma)
            avance += UNIDAD_DE_AVANCE
            continue

        else:
            estados.encolar(avance)
            avance = 0
            estados.encolar(accion)

    if avance != 0:
        estados.encolar(avance)
    return estados