def main():
pizzaria = Fila()
pedido1 = Pedido("Muçarela")
pedido2 = Pedido("Calabraza")
pedido3 = Pedido("Marguerita")
pedido4 = Pedido("Rúcula")
pizzaria.entrar(pedido1)
pizzaria.entrar(pedido2)
pizzaria.entrar(pedido3)
pizzaria.entrar(pedido4)
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
pedido = pizzaria.sair()
print("Fazendo pizza: {}".format(pedido))
print("Está vazia? {}".format(pizzaria.vazia))
class PainelAtendimento:
def __init__(self):
self.fila = Fila()
self.removidas = []
def obtem_senha(self):
if self.fila.is_empty():
nova_senha = 0
self.fila.enqueue(0)
else:
nova_senha = self.fila.front() + len(self.fila)
self.fila.enqueue(nova_senha)
return nova_senha
def chama_proxima_senha(self):
if self.fila.is_empty():
senha_atendida = None
else:
proxima_senha = self.fila.front()
self.removidas.append(proxima_senha)
senha_atendida = proxima_senha
self.fila.dequeue()
return senha_atendida
def mostra_senhas_chamadas(self):
if len(self.removidas) == 0:
return None
else:
return self.removidas
def run(self):
while True:
try:
print("Olá, bem-vindo(a) ao painel de atendimento! \n")
opcao = int(
input(
"Escolha uma das opções abaixo:\n 1 - Obter senha.\n 2 - Chamar próxima senha.\n 3 - Mostar as senhas chamadas.\n 4 - Encerrar sistema.\n"
))
if opcao == 1:
senha = self.obtem_senha()
print(f"Sua senha é: {senha}\n")
elif opcao == 2:
proxima_senha = self.chama_proxima_senha()
if proxima_senha == None:
print(
"Ainda não há nenhuma senha salva, ou todas já foram chamadas. Por gentileza cadastre uma senha.\n"
)
else:
print(f"A senha chamada foi: {proxima_senha}.\n")
elif opcao == 3:
removidas = self.mostra_senhas_chamadas
if removidas == None:
print("Nenhuma senha foi removida até o momento.\n")
else:
print(f"As senhas chamadas foram: {self.removidas}.\n")
elif opcao == 4:
print("Obrigada por utilizar o sistema!!")
break
except:
print("Opção inválida, tente novamente!")
def test_float(self):
fila = Fila()
fila.enfileirar('1234567890')
fila.enfileirar('.')
fila.enfileirar('4')
fila_sintatica = analise_sintatica(fila)
self.assertEqual(1234567890.4, fila_sintatica.desenfileirar())
self.assertTrue(fila_sintatica.vazia())
def main():
vagas = Fila()
print('Comandos\n', 'A - adicionar carro\n', 'R - remover carro\n',
'S - mostrar statatus do estacionamento\n',
'E - Encerrar o programa')
print()
comando = input('Insira o comando desejado: ').upper()
while comando != 'E':
if comando == 'A':
placa = input('Informe o numero da placa: ')
vagas.inserirDado(placa)
comando = input('Insira o comando desejado: ').upper()
elif comando == 'R':
placa = input('Informe a placa do carro que quer remover: ')
vagas.remove(placa)
comando = input('Insira o comando desejado: ').upper()
elif comando == 'S':
print(vagas.getFila())
comando = input('Insira o comando desejado: ').upper()
def analise_lexica(expressao):
"""
Executa análise lexica transformando a expressao em fila de objetos:
Transforma inteiros em ints
Flutuantes em floats
e verificar se demais caracteres são validos: +-*/(){}[]
:param expressao: string com expressao a ser analisada
:return: fila com tokens
"""
fila = Fila()
#Aqui ficam os numeros e o Token
nt = R"0123456789.-+*/{}[]()"
if expressao:
valor = ''
for a in expressao:
if a in nt:
if a in '.-+*/{}[]()':
if valor:
fila.enfileirar(valor)
valor = ''
fila.enfileirar(a)
else:
valor = valor + a
else:
raise ErroLexico()
if valor:
fila.enfileirar(valor)
return fila
def test__eq__n_elements_queues(self):
"""Duas filas com os mesmos elementos são iguais"""
x = randint(100, 500)
fila1 = Fila()
fila2 = Fila()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
fila1.enqueue(element)
fila2.enqueue(element)
self.assertEqual(fila1, fila2)
self.assertEqual(fila1, fila2)
def test_dequeue(self):
"""dequeue diminui o tamanho da fila em 1"""
self.assertEqual(len(self.fila_um), 1)
self.fila_um.dequeue()
self.assertEqual(len(self.fila_um), 0)
self.assertEqual(self.fila_um, Fila())
size = len(self.fila_limite)
self.fila_limite.dequeue()
self.assertEqual(len(self.fila_limite), size - 1)
class Restaurante:
def __init__(self):
self.entrada = Fila()
self.mesas = [Mesa(), Mesa(), Mesa(), Mesa()]
self.caixas = [Fila(), Fila()]
self.tempo = 2
def localiza_mesa_disponivel(self):
for mesa in self.mesas:
if (mesa.verificarSeDesocupada()):
return mesa
return
def recepcionar_adicionar_clientes_mesa(self, clientes):
for mesa in self.mesas:
if (mesa.verificarSeDesocupada()):
mesa.ocupar(clientes)
return
return clientes
def remover_clientes_mesa(self, mesa):
clientes = mesa.desocupar()
self.adicionar_fila_caixa(clientes)
def adicionar_fila_caixa(self, clientes):
if self.caixas[0].obter_tamanho() <= self.caixas[1].obter_tamanho():
self.caixas[0].adicionar(clientes)
else:
self.caixas[1].adicionar(clientes)
def remover_fila_caixa(self):
if (self.caixas[0].fim != -1):
return self.caixas[0].remover()
elif (self.caixas[1].fim != -1):
return self.caixas[1].remover()
else:
return
def adicionar_fila_entrada(self, clientes):
self.entrada.adicionar(clientes)
def remover_fila_entrada(self):
return self.entrada.remover()
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.fila_vazia = Fila()
self.x = randint(0, maxsize)
self.fila_um = Fila()
self.fila_um.enqueue(self.x)
self.max = randint(100, 500)
self.fila = Fila()
self.fila.enqueue(self.x)
self.fila_limite = Fila(self.max)
self.python_deque = deque()
for i in range(0, self.max):
element = randint(0, self.MAX_VALUE)
self.python_deque.append(element)
self.fila_limite.enqueue(element)
def test_str_n_elements_queue(self):
"""Uma fila com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no final,
mas também é possível inserir no final e retirar no começo"""
fila = Fila()
fila.enqueue(1)
fila.enqueue(2)
fila.enqueue(3)
fila.enqueue(4)
self.assertEqual(str(fila), "[4, 3, 2, 1]")
class TestFila(TestCase):
def setUp(self):
self.fila = Fila([0, 1, 2, 3, 4, 5])
def test_pop(self):
self.assertEqual(self.fila.pop(), 0)
def test_pop_all(self):
with self.assertRaises(IndexError):
while self.fila:
self.fila.pop()
def test_intert(self):
self.fila.insert(10)
self.assertIn(10, self.fila.numeros)
def test_min(self):
menor = self.fila.min()
self.assertEqual(menor, 0)
def test_max(self):
maior = self.fila.max()
self.assertEqual(maior, 5)
def test__eq__empty_queues(self):
"""Duas filas vazias são iguais"""
self.assertEqual(Fila(), Fila())
#o argumento é a capacidade da fila
self.assertEqual(Fila(5), Fila(10))
from no import No
from dado import Dado
from fila import Fila
from pilha import Pilha
from lista import Lista
#import os
import time
fila = Fila()
pilha = Pilha()
no = No()
lista = Lista()
print('PROJETO ESTRUTURA DE DADOS - PILHA - FILA - LISTA')
print('PROFESSOR: THIAGO MOURA')
print('ALUNOS:\nDAVID LUCAS;\nMARIA REBECA.')
time.sleep(5)
while True:
print('=======================================')
print('Escolha uma das opções abaixo:\n'
'1. Pilha\n'
'2. Fila\n'
'3. Lista\n'
'0. Sair\n')
op = int(input('Opção: '))
if op == 0:
print('Encerrando operações!')
break
# PILHA
elif op == 1:
while True:
print('======================================')
from fila import Fila
fila_sem_max = Fila()
# testando inserir em fila sem maximo de elementos definidos.
print("fila sem maximo de elementos definidos")
fila_sem_max.inserir("Joker")
fila_sem_max.inserir("Bruce Wayne")
fila_sem_max.inserir("James Gordon")
fila_sem_max.inserir("Selina")
print(fila_sem_max)
# testando inserir em fila com maximo de elementos definidos.
fila_com_max = Fila(max_tamanho=5)
fila_com_max.inserir("Comedian")
fila_com_max.inserir("Spectral")
fila_com_max.inserir("Sally Jupiter")
fila_com_max.inserir("Roschach")
fila_com_max.inserir("Night Owl")
print("fila com maximo de elementos definidos")
print(fila_com_max)
try:
fila_com_max.inserir("Manhattan")
except Exception:
print("A fila está cheia")
for i in range(fila_sem_max.tamanho()):
print(fila_sem_max.remover())
def analise_sintatica(fila):
"""
Função que realiza analise sintática de tokens produzidos por analise léxica.
Executa validações sintáticas e se não houver erro retorn fila_sintatica para avaliacao
:param fila: fila proveniente de análise lexica
:return: fila_sintatica com elementos tokens de numeros
"""
if fila.__len__():
# Cria um novo objeto fila para adicionar os valores
fila_sintetica = Fila()
#Variavel de apoio para juntar a string
valor = ''
for a in range(fila.__len__()):
if fila._deque[a] in '-+/*(){}[]':
if valor:
if '.' in valor:
fila_sintetica.enfileirar(float(valor))
else:
fila_sintetica.enfileirar(int(valor))
valor = ''
fila_sintetica.enfileirar(fila._deque[a])
else:
valor = valor + fila._deque[a]
if valor:
if '.' in valor:
fila_sintetica.enfileirar(float(valor))
else:
fila_sintetica.enfileirar(int(valor))
return fila_sintetica
else:
raise ErroSintatico
def menu():
print ('Entre com a opcao: \n', \
'1 para inserir na pilha \n', \
'2 para retirar na pilha\n', \
'3 para mostra o proximo valor a ser retirado da pilha \n', \
'4 verificar se esta vazia \n', \
'##################################### \n', \
'5 para inserir na fila \n', \
'6 para retirar na fila\n', \
'7 para mostra o proximo valor a ser retirado da fila \n', \
'8 verificar se esta vazia \n', \
'9 para finalizar o programa \n')
pilha = Pilha()
fila = Fila()
menu()
contro = input(' ? ')
while contro != 9:
if contro == '1':
pilha.push(input('Qual o valor ?'))
elif contro == '2':
pilha.pop()
elif contro == '3':
pilha.peek()
elif contro == '4':
pilha.empty()
elif contro == '5':
fila.push(input('Qual o valor ?'))
elif contro == '6':
def __init__(self, max_elementos):
self.__pilha = Pilha()
self.__fila = Fila()
self.__max_elementos = max_elementos
def executar(self, n_rodadas, fregueses_por_rodada, rho, n_transiente):
""" Funcao de execucao do simulador
Args:
n_fregueses: numero de fregueses
n_rodadas: numero de rodadas da simulacao.
rho: taxa
"""
''' Inicializacao '''
lambd = rho/2 # taxa de chegada.
taxa_servico = 1 # taxa de servico.
fila1 = Fila(1) # fila 1, mais prioritaria (chegadas exogenas).
fila2 = Fila(2) # fila 2, menos prioritaria (nao ha chagadas exogenas).
# eventos = [] # lista de eventos.
total_fregueses_servidos = 0 # total de fregueses que passaram pelo sistema.
total_fregueses_criados = 0 # total de fregueses criados pelo sistema
tempo = 0 # tempo atual da simulacao.
rodada_atual = 0 # rodada da fase transiente.
fregues_executando = None # inicializacao nula do fregues executando.
plot = Plot()
intervalo = (n_transiente + (fregueses_por_rodada * n_rodadas)) * 0.1
metricas = Metrica(n_rodadas, fregueses_por_rodada)
if n_transiente > 0:
id_proximo_fregues = - n_transiente
else:
id_proximo_fregues = 0 # id do proximo fregues a ser criado (fase transiente arbitraria)
''' Casos DETERMINISTICOS '''
deterministico = False
xs1 = [0]
xs2 = [0]
if deterministico: # Caso de Interrupcao.
chegadas = [1, 4] # Os vetores representam caracteristicas de todos os fregueses.
xs1 = [1, 2]
xs2 = [5, 2]
# chegadas = [0, 4] # Caso de Servidor Ocioso.
# xs1 = [1, 1]
# xs2 = [1, 2]
''' Execucao da SIMULACAO '''
inicio = datetime.now()
while total_fregueses_servidos < n_rodadas * fregueses_por_rodada: # Loop de execucao sobre as RODADAS.
# Tempo de chegada conforme sistema Deterministico:
if deterministico:
if len(chegadas) > 0:
tempo_ate_prox_chegada = chegadas.pop(0)-tempo
else:
tempo_ate_prox_chegada = 10
# Tempo de chegada conforme sistema Exponencial:
else:
tempo_ate_prox_chegada = Utils.gera_taxa_exp(lambd)
tempo += tempo_ate_prox_chegada
# Loop de execucao enquanto ainda nao chegar um novo fregues
while tempo_ate_prox_chegada > 0 and fregues_executando is not None:
# Se a execucao do fregues acabar antes da proxima chegada.
if fregues_executando.tempo_restante <= tempo_ate_prox_chegada:
tempo_ate_prox_chegada -= fregues_executando.tempo_restante # O tempo ate a prox chegada sera subtraido do tempo de servico do fregues em execucao
fregues_executando.tempo_restante = 0
tempo_atual = tempo - tempo_ate_prox_chegada
cor = fregues_executando.cor
# eventos.append(Evento(tempo_atual, fregues_executando.fregues_id, TipoEvento.FIM_SERVICO, fregues_executando.prioridade))
# Atualizacao de metricas de acordo com a fila do fregues (1 ou 2).
# E realizacao da troca de filas (para o fregues que executou em 1) ou evento de fim de execucao (fregues dafila 2)
if fregues_executando.prioridade == 1:
w1 = tempo_atual - fregues_executando.tempo_chegada1 - fregues_executando.tempo_servico1
if cor <= n_rodadas: # so calcula metricas dos fregueses ate n_rodadas
metricas.acumula_w1(w1, cor)
plot.w1_acumulado += w1
metricas.acumula_t1(w1, cor)
fregues_executando.troca_fila(tempo_atual)
fila2.adiciona(fregues_executando)
# eventos.append(Evento(tempo_atual, fregues_executando.fregues_id, TipoEvento.CHEGADA, 2))
else:
w2 = tempo_atual - fregues_executando.tempo_chegada2 - fregues_executando.tempo_servico2
if cor <= n_rodadas: # so calcula metricas dos fregueses ate n_rodadas
metricas.acumula_w2(w2, cor)
plot.w2_acumulado += w2
metricas.acumula_t2(w2, cor)
# if para garantir que os fregueses das rodadas foram os servidos
if fregues_executando.cor > 0 and fregues_executando.cor <= n_rodadas:
total_fregueses_servidos += 1
# Caso exista freguese na fila: coloca-lo em execucao (Prioridade para fila 1).
if fila1.tamanho() > 0:
fregues_executando = fila1.proximo_fregues()
else:
if fila2.tamanho() > 0:
fregues_executando = fila2.proximo_fregues()
else:
fregues_executando = None
# Caso chegue um outro fregues no meio da execucao do fregues atual.
else:
fregues_executando.tempo_restante -= tempo_ate_prox_chegada
tempo_ate_prox_chegada = 0
# Tratando as rodadas.
if id_proximo_fregues >= 0 and id_proximo_fregues % fregueses_por_rodada == 0:
rodada_atual += 1
if deterministico and total_fregueses_servidos == fregueses_por_rodada:
break
# Chega um novo fregues: entra na fila 1.
fregues = Fregues(id_proximo_fregues, tempo, taxa_servico, rodada_atual, xs1[0], xs2[0])
if deterministico:
del xs1[0]
del xs2[0]
# Atualizacao de Metricas.
if rodada_atual <= n_rodadas:
metricas.acumula_x1(fregues.tempo_servico1, rodada_atual)
metricas.acumula_t1(fregues.tempo_servico1, rodada_atual)
metricas.acumula_nq1(fila1.tamanho(), rodada_atual)
metricas.acumula_n1(fila1.tamanho(), rodada_atual)
metricas.acumula_x2(fregues.tempo_servico2, rodada_atual)
metricas.acumula_t2(fregues.tempo_servico2, rodada_atual)
metricas.acumula_nq2(fila2.tamanho(), rodada_atual)
metricas.acumula_n2(fila2.tamanho(), rodada_atual)
plot.nq1_acumulado += fila1.tamanho()
plot.nq2_acumulado += fila2.tamanho()
# eventos.append(Evento(tempo, id_proximo_fregues, TipoEvento.CHEGADA, 1))
# Rotina de verificacao de quem deve executar.
if fregues_executando is None:
fregues_executando = fregues
else: # Interrupcao, Novo fregues executa.
if fregues_executando.prioridade == 2:
fila2.volta_para_fila(fregues_executando)
fregues_executando = fregues
if rodada_atual <= n_rodadas:
metricas.acumula_ns2(1, rodada_atual)
plot.ns2_acumulado += 1
metricas.acumula_n2(1, rodada_atual)
else: # Novo fregues para fila 1.
fila1.adiciona(fregues)
if rodada_atual <= n_rodadas:
metricas.acumula_ns1(1, rodada_atual)
plot.ns1_acumulado += 1
metricas.acumula_n1(1, rodada_atual)
id_proximo_fregues += 1
total_fregueses_criados += 1
# if id_proximo_fregues % intervalo == 0:
plot.w1.append(plot.w1_acumulado / total_fregueses_criados)
plot.nq1.append(plot.nq1_acumulado / total_fregueses_criados)
plot.ns1.append(plot.ns1_acumulado / total_fregueses_criados)
plot.w2.append(plot.w2_acumulado / total_fregueses_criados)
plot.nq2.append(plot.nq2_acumulado / total_fregueses_criados)
plot.ns2.append(plot.ns2_acumulado / total_fregueses_criados)
# Impressao dos parametros de entrada.
tabela_parametros = PrettyTable(["n_rodadas", "fregueses/rodada", "fase_transiente", "rho", "lambda"])
tabela_parametros.add_row([n_rodadas, fregueses_por_rodada, n_transiente, rho, lambd])
print(tabela_parametros, "\n")
# Calculo e impressao das metricas.
metricas.calcula(deterministico)
fim = datetime.now()
total = fim - inicio
print("Tempo de execucao: " + str(total))
# plota os graficos
plot.desenha(intervalo, n_rodadas, fregueses_por_rodada, n_transiente, rho)
from no import No
from dado import Dado
from pilha import Pilha
from lista import Lista
from fila import Fila
pilha = Pilha()
lista = Lista()
fila = Fila()
no = No()
# LISTA
l1 = Dado('Avengers', 2019, 'Marvel')
l2 = Dado('Batman Begins', 2005, 'Warner Bros')
l3 = Dado('The Simpsons', 2006, 'FOX')
l4 = Dado('Spider-Man - Homecoming', 2017, 'Sony')
l5 = Dado('Toy Story', 2019, 'Pixar')
#lista.remove(l1)
lista.append(l1)
lista.append(l2)
print(lista.Tamanho())
lista.insert(1, l3)
lista.insert(0, l4)
print(lista.Tamanho())
print(lista.Listando())
print('\n\n')
lista.insert(7, l5)
print(lista.Listando())
#lista.remove()
print(lista.Listando())
#lista.remove(l1)
from fila import Fila
fila1 = Fila()
fila1.inserirDado(0)
fila1.inserirDado(1)
fila1.inserirDado(2)
print(fila1.getFila())
fila1.remover()
print(fila1.getFila())
fila1.removerDado(2)
tam = fila1.tamanhoFila()
if (tam != 0):
print(fila1.getFila())
else:
print("Lista Vazia")
from fila import Fila
from random import randint
from time import sleep
import sys
filaBanco = Fila()
def EntrarNaFila(cliente):
print("Cliente entrando na fila do caixa...")
filaBanco.ENQUEUE(cliente)
def Atender():
for i in range(filaBanco.LENGTH()):
cliente = filaBanco.DEQUEUE()
tempo_Atendimento = randint(1,10)
print("Cliente sendo atendido...\n")
sleep(tempo_Atendimento)
print("Atendimento terminado!\n")
print("O atendimento demorou %d minutos. "%(tempo_Atendimento))
def Sair():
print("Saindo...")
sys.exit()
def main():
print("-------------- BANCO--------------\n")
print("TECLE: \n", "1- Entrar na fila do caixa de atendimento\n", "2- Atendimento\n","3- Sair.\n")
from pilha import Pilha
from fila import Fila
pilha = Pilha()
fila = Fila()
lista = ['N', 'O', 'H', 'T', 'Y', 'P']
for item in lista:
pilha.push(item)
for i in range(pilha.length()):
letra = pilha.pop()
fila.ENQUEUE(letra)
lista_reversa = []
for i in range(fila.LENGTH()):
letra2 = fila.DEQUEUE()
lista_reversa.append(letra2)
print(lista_reversa)
from fila import Fila
from random import randint
from time import sleep
import sys
filaImpressao = Fila()
def adicionarFilaImpressao(documento):
print("Adicionando documento a fila de impressao, aguarde...")
filaImpressao.ENQUEUE(documento)
def imprimir():
for i in range(filaImpressao.LENGTH()):
documento = filaImpressao.DEQUEUE()
tempo_impressao = randint(1,10)
print("Imprimindo...\n")
sleep(tempo_impressao)
print("Documento impresso!\n")
print("A impressão levou: %ds"%(tempo_impressao))
def sair():
print("Saindo...")
sys.exit()
def main():
print("-------------- IMPRESSORA--------------\n")
print("TECLE: \n", "1- Adicionar documento na fila de impressão\n", "2- Imprimir\n","3- Sair.\n")
def main():
filaTeste = Fila()
filaTeste.inserirdados("ifpb")
filaTeste.inserirdados("teste")
filaTeste.inserirdados("valor final")
print(filaTeste.getFila())
filaTeste.removerDado()
print(filaTeste.getFila())
filaTeste.removev("teste")
#remove o teste
print(filaTeste.remove())
#sai o primeiro valor
print(filaTeste.TamanhoFila())
def __init__(self):
self.entrada = Fila()
self.mesas = [Mesa(), Mesa(), Mesa(), Mesa()]
self.caixas = [Fila(), Fila()]
self.tempo = 2
from fila import Fila
from tkinter import *
f1 = Fila()
class Application:
#Construtor
def __init__(self, master=None):
self.fonte = ("Verdana", "8")
self.container1 = Frame(master)
self.container1["pady"] = 10
self.container1.pack()
self.container3 = Frame(master)
self.container3["padx"] = 20
self.container3["pady"] = 5
self.container3.pack()
self.container4 = Frame(master)
self.container4["padx"] = 20
self.container4["pady"] = 5
self.container4.pack()
self.container5 = Frame(master)
self.container5["padx"] = 20
self.container5["pady"] = 5
self.container5.pack()
self.container6 = Frame(master)
self.container6["padx"] = 20
self.container6["pady"] = 10
self.container6.pack()
self.container7 = Frame(master)
class TesteFila(unittest.TestCase):
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.fila_vazia = Fila()
self.x = randint(0, maxsize)
self.fila_um = Fila()
self.fila_um.enqueue(self.x)
self.max = randint(100, 500)
self.fila = Fila()
self.fila.enqueue(self.x)
self.fila_limite = Fila(self.max)
self.python_deque = deque()
for i in range(0, self.max):
element = randint(0, self.MAX_VALUE)
self.python_deque.append(element)
self.fila_limite.enqueue(element)
def test_construtor(self):
"""O construtor deve receber um valor max ou None"""
self.assertIsInstance(self.fila_um, Fila)
self.assertIsInstance(self.fila_vazia, Fila)
self.assertIsInstance(self.fila, Fila)
self.assertIsInstance(self.fila_limite, Fila)
def test_bool_false(self):
"""Uma Fila Vazia retorna False"""
self.assertFalse(bool(self.fila_vazia))
self.assertFalse(self.fila_vazia)
self.assertFalse(self.fila_vazia.__bool__())
def test_bool_true(self):
"""Uma Fila com 1 elemento retorna True"""
self.assertTrue(bool(self.fila_um))
self.assertTrue(self.fila_um)
self.assertTrue(self.fila_um.__bool__())
def test_empty_queue(self):
"""Uma Fila Vazia retorna True para is_empty"""
self.assertTrue(self.fila_vazia.is_empty())
def test_not_empty_queue(self):
"""Uma Fila Não Vazia retorna False para is_empty"""
self.assertFalse(self.fila_um.is_empty())
def test_len_empty_queue(self):
"""Uma Fila Vazia tem tamanho 0"""
self.assertEqual(len(self.fila_vazia), 0)
def test_len_one_element_queue(self):
"""Uma Fila com 1 elemento tem tamanho 1"""
self.assertEqual(len(self.fila_um), 1)
#Este Teste só funciona quando enqueue tiver sido implementado
def test_len_arbitrary_size_queue(self):
"""Uma Fila com n elementos tem tamanho n"""
self.assertEqual(len(self.fila_limite), self.max)
def test_first_empty_queue(self):
"""Uma Fila vazia retorna uma Exceção quando first é invocado"""
with self.assertRaises(Exception):
self.fila_vazia.first()
def test_first_one_element_queue(self):
"""Uma Fila com 1 elemento retorna o elemento com first"""
self.assertEqual(self.fila_um.first(), self.x)
def test_first_n_elements_queue(self):
"""Uma Fila com n elementos retorna o primeiro a ter sido inserido com first"""
self.assertEqual(self.fila_limite.first(), self.python_deque.popleft())
def test_first_doesnt_change_queue_len(self):
"""O método first é idempotente e não altera o tamanho da fila"""
size = len(self.fila_limite)
self.assertEqual(len(self.fila_limite), size)
self.fila_limite.first()
self.fila_limite.first()
self.fila_limite.first()
self.fila_limite.first()
self.fila_limite.first()
self.assertEqual(len(self.fila_limite), size)
def test_last_empty_queue(self):
"""Uma Fila vazia retorna uma Exceção quando last é invocado"""
with self.assertRaises(Exception):
self.fila_vazia.last()
def test_last_one_element_queue(self):
"""Uma Fila com 1 elemento retorna o elemento com last"""
self.assertEqual(self.fila_um.last(), self.x)
def test_last_n_elements_queue(self):
"""Uma Fila com n elementos retorna o último a ter sido inserido com last"""
self.assertEqual(self.fila_limite.last(), self.python_deque.pop())
def test_last_doesnt_change_queue_len(self):
"""O método last é idempotente e não altera o tamanho da fila"""
size = len(self.fila_limite)
self.assertEqual(len(self.fila_limite), size)
self.fila_limite.last()
self.fila_limite.last()
self.fila_limite.last()
self.fila_limite.last()
self.fila_limite.last()
self.assertEqual(len(self.fila_limite), size)
def test__eq__empty_queues(self):
"""Duas filas vazias são iguais"""
self.assertEqual(Fila(), Fila())
#o argumento é a capacidade da fila
self.assertEqual(Fila(5), Fila(10))
def test__eq__n_elements_queues(self):
"""Duas filas com os mesmos elementos são iguais"""
x = randint(100, 500)
fila1 = Fila()
fila2 = Fila()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
fila1.enqueue(element)
fila2.enqueue(element)
self.assertEqual(fila1, fila2)
self.assertEqual(fila1, fila2)
def test_str_empty_queue(self):
"""Uma fila vazia deve ser representada pela string []"""
self.assertEqual(str(self.fila_vazia), "[]")
def test_str_one_element_queue(self):
"""Uma fila com somente um elemento x deve ser representada por [x]"""
self.assertEqual(str(self.fila_um), "[" + str(self.x) + "]")
def test_str_n_elements_queue(self):
"""Uma fila com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no final,
mas também é possível inserir no final e retirar no começo"""
fila = Fila()
fila.enqueue(1)
fila.enqueue(2)
fila.enqueue(3)
fila.enqueue(4)
self.assertEqual(str(fila), "[4, 3, 2, 1]")
def test_clear_remove_all_elements(self):
"""clear remove todos os elementos da fila"""
self.assertEqual(len(self.fila_vazia), 0)
self.assertNotEqual(len(self.fila_um), 0)
self.assertNotEqual(len(self.fila_limite), 0)
self.fila_vazia.clear()
self.fila_um.clear()
self.fila_limite.clear()
self.assertEqual(len(self.fila_vazia), 0)
self.assertEqual(len(self.fila_um), 0)
self.assertEqual(len(self.fila_limite), 0)
def test_enqueue(self):
"""enqueue aumenta o tamanho da fila em 1"""
element = randint(0, self.MAX_VALUE)
self.assertEqual(len(self.fila_vazia), 0)
self.assertEqual(len(self.fila_um), 1)
self.fila_vazia.enqueue(element)
self.fila_um.enqueue(element)
self.assertEqual(len(self.fila_vazia), 1)
self.assertEqual(len(self.fila_um), 2)
def test_enqueue_full_queue(self):
"""enqueue numa lista cheia gera um erro"""
with self.assertRaises(Exception):
element = randint(0, self.MAX_VALUE)
self.fila_limite.enqueue(element)
def test_dequeue(self):
"""dequeue diminui o tamanho da fila em 1"""
self.assertEqual(len(self.fila_um), 1)
self.fila_um.dequeue()
self.assertEqual(len(self.fila_um), 0)
self.assertEqual(self.fila_um, Fila())
size = len(self.fila_limite)
self.fila_limite.dequeue()
self.assertEqual(len(self.fila_limite), size - 1)
def test_dequeue_empty_queue(self):
"""dequeue numa lista vazia gera um erro"""
with self.assertRaises(Exception):
self.fila_vazia.dequeue()
def test_enqueue_dequeue_1(self):
"""teste de integração pipeline de filas"""
fila1 = Fila()
fila2 = Fila()
fila3 = Fila()
fila4 = Fila()
for i in range(0, self.max):
fila1.enqueue(i)
fila2.enqueue(fila1.dequeue())
fila3.enqueue(fila2.dequeue())
fila4.enqueue(fila3.dequeue())
self.assertEqual(i, fila4.dequeue())
def __init__(self, grafo, vertice):
fila = Fila()
#lista para guardar os vertices por distancia
auxDist = []
for i in range(len(grafo)):
auxDist.append([])
cont = 1
self.__vetor_distancias = ([0] * len(grafo))
self.__vetor_visitacao = ([-1] * len(grafo))
fila.QEUEput(vertice)
fila.QEUEput(-1) # separa a fila por camada
self.__vetor_visitacao[vertice] = cont
cont += 1
distancia = 0
while fila.QEUEempty() != 0:
v = fila.QEUEget()
#se o v for igual a -1 significa que e o fim da fila
if v != -1:
camada = fila.QEUEget()
#aumenta a distancia caso a camada = -1,
aux = distancia
if camada == -1:
distancia += 1
else:
#se a camada nao for igual a -1, ela e inserida novamente no inicio da fila,
# pois se trata de um vertice
fila.addInicioDaFila(camada)
#preenche o vetor de visitaçao
for i in grafo[v]:
if self.__vetor_visitacao[i] == -1:
self.__vetor_visitacao[i] = cont
cont = cont + 1
fila.QEUEput(i)
#verifico se minha distancia mudou
#caso a distancia tenha mudado, insiro meus vertices pertencentes a distancia
if aux != distancia:
auxDist[distancia] = (fila.getFila())
fila.QEUEput(
-1
) # insiro no fim da fila para identificar que e outra camada
#mantem na lista de distancia apenas, as listas nao nulas
auxDist2 = []
for i in auxDist:
if len(i) != 0:
auxDist2.append(i)
#soma a quantidade de cidades por cada distancia
cont = 0
for i in auxDist2:
soma = 0
for j in i:
soma += 1
self.__vetor_distancias[cont] = soma
cont += 1
fila.QEUEfree()
def test_enqueue_dequeue_1(self):
"""teste de integração pipeline de filas"""
fila1 = Fila()
fila2 = Fila()
fila3 = Fila()
fila4 = Fila()
for i in range(0, self.max):
fila1.enqueue(i)
fila2.enqueue(fila1.dequeue())
fila3.enqueue(fila2.dequeue())
fila4.enqueue(fila3.dequeue())
self.assertEqual(i, fila4.dequeue())
def setUp(self):
self.fila = Fila([0, 1, 2, 3, 4, 5])
def __init__(self):
self.fila = Fila()
self.removidas = []
from fila import Fila
from pilha import Pilha
from listaencadeada import Lista_Encadeada
#Teste da fila
print('Teste da fila')
f = Fila()
f.inserir(10)
f.inserir(20)
f.inserir(30)
print(f.retornar_lista())
f.remover()
print(f.retornar_lista())
# Teste da pilha
print('Teste da pilha')
p = Pilha()
p.inserir(10)
p.inserir(20)
p.inserir(30)
print(p.retornar_lista())
p.remover()
print(p.retornar_lista())
#Teste da lista encadada
print('Teste da lista encadada')
e = Lista_Encadeada()
e.inserir(0, 10)
e.inserir(0, 20)
e.inserir(1, 30)
print(e.retornar_lista())
from fila import Fila
def menu():
print ('Entre com a opcao: \n', \
'1 para inserir no inicio \n', \
'2 para inserir no final\n', \
'3 para retirar no inicio \n', \
'4 para retirar no final \n', \
'5 para mostrar no inicio da fila \n', \
'6 para mostrar no fim da fila \n', \
'7 finalizar \n')
fila = Fila()
menu()
contro = input(' ? ')
while contro != 9:
if contro == '1':
fila.pushFront(input('Qual o valor ?'))
elif contro == '2':
fila.pushBack(input('Qual o valor ?'))
elif contro == '3':
fila.popFront()
elif contro == '4':
fila.popBack()
elif contro == '5':
fila.peekFront()
elif contro == '6':
fila.peekBack()
