def finding_isles(self):
"""Método que identifica as ilhas"""
pilha = Pilha()
rot = 2
flag = 0
for line in range(0, self.lines):
print("a")
for column in range(0, self.columns):
print("b")
while (flag == 0):
print("c")
if self.matriz[line][column] == 1:
pilha.push(line, column)
print(len(pilha))
fnc.label(self.matriz, line, column, rot)
fnc.checking_neighbors(self.matriz, pilha, line,
column, rot)
if (pilha.top == None):
rot = rot + 1
elif ((self.matriz[line][column] == rot)
and (pilha.top != None)):
line = pilha.top.line
column = pilha.top.column
fnc.checking_neighbors(self.matriz, pilha, line,
column, rot)
if (pilha.top == None):
rot = rot + 1
elif (pilha.top == None):
flag = 1
flag = 0
def __init__(self, id):
self.nome = id
#self.numVertices = m
#self.numArestas = n
self.arestas = []
self.vertices = []
self.pilha = Pilha()
self.ciclo = False
def main():
pilha = Pilha()
string = input(
'Digite as caracters que deseja inserir na pilha (insira todas as caracters juntas): '
)
[pilha.pushPilha(c) for c in string]
print(pilha.getPilha())
def test_empilhar_em_pilha_cheia(self): p = Pilha() p.empilha(1) p.empilha(2) p.empilha(3) self.assertTrue(p.pilhaCheia()) self.assertEqual(p.tamanho(), 3) p.empilha(4) self.assertFalse(p.empilha(4))
def test_str_n_elements_stack(self):
"""Uma pilha com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no começo,
mas também é possível inserir no final e retirar no final"""
pilha = Pilha()
pilha.push(1)
pilha.push(2)
pilha.push(3)
pilha.push(4)
self.assertEqual(str(pilha), "[4, 3, 2, 1]")
def main():
pilha = Pilha()
pilha1 = [
"Esta",
"pilha",
"não",
"é",
"maior",
]
pilha2 = ["do", "que", "esta", "pilha", "aqui", "xD"]
print(pilha.testaMaisElementos(pilha1, pilha2))
def test_empilha_elementos(self): p = Pilha() p.empilha(1) self.assertFalse(p.pilhaVazia()) self.assertEqual(p.tamanho(), 1) p.empilha(2) self.assertFalse(p.pilhaVazia()) self.assertEqual(p.tamanho(), 2)
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.pilha_vazia = Pilha()
self.x = randint(0, maxsize)
self.pilha_um = Pilha()
self.pilha_um.push(self.x)
self.max = randint(100, 500)
self.pilha = Pilha()
self.pilha.push(self.x)
self.pilha_limite = Pilha(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.pilha_limite.push(element)
def test__eq__n_elements_stacks(self):
"""Duas pilhas com os mesmos elementos são iguais"""
x = randint(100, 500)
pilha1 = Pilha()
pilha2 = Pilha()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
pilha1.push(element)
pilha2.push(element)
self.assertEqual(pilha1, pilha2)
self.assertEqual(pilha1, pilha2)
def test_pop(self):
"""pop diminui o tamanho da pilha em 1"""
self.assertEqual(len(self.pilha_um), 1)
self.pilha_um.pop()
self.assertEqual(len(self.pilha_um), 0)
self.assertEqual(self.pilha_um, Pilha())
size = len(self.pilha_limite)
self.pilha_limite.pop()
self.assertEqual(len(self.pilha_limite), size - 1)
def isPalindromo(wr):
tam = len(wr)
fim = "."
mid = (tam // 2) + (tam % 2) #define o meio da palavra
pilha = Pilha()
pilha.push(fim)
if (tam < 3): return False
for i in range(tam):
if i < mid - 1:
pilha.push(wr[i])
elif (i == mid - 1):
continue
else:
x = pilha.peek()
if (x == wr[i]):
pilha.pop()
return (pilha.peek() == fim)
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.pilha_vazia = Pilha()
self.x = randint(0, maxsize)
self.pilha_um = Pilha()
self.pilha_um.push(self.x)
self.max = randint(100, 500)
self.pilha = Pilha()
self.pilha.push(self.x)
self.pilha_limite = Pilha(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.pilha_limite.push(element)
def __init__(self, coordenada, quadrante, n=None):
'''Recebe uma coordenada e um Quadrante correspondente. Se o valor n inicial não for informado, o padrão é None.'''
self.n = n
self.coordenada = coordenada
self.quadrante = quadrante
self.retirados = Pilha()
self.conflitos = 0
# Operações feitas sobre o domínio: adicionar, remover, contém/não contém
# Dominio poderia ser representado por uma lista ou por um set.
# Lista: append(1), remove O(n), in/not in O(n)
# Set: add O(1), remove O(1), in/not in O(1)
if self.n is None: self.dominio = {1, 2, 3, 4, 5, 6, 7, 8, 9}
else: self.dominio = {n}
def test_str_n_elements_stack(self):
"""Uma pilha com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no começo,
mas também é possível inserir no final e retirar no final"""
pilha = Pilha()
pilha.push(1)
pilha.push(2)
pilha.push(3)
pilha.push(4)
self.assertEqual(str(pilha), "[4, 3, 2, 1]")
def __init__(self, dados, entrada):
self.entrada = [entry for entry in entrada]
self.alfabeto_entrada = dados['alfabeto_entrada']
self.alfabeto_pilha = dados['alfabeto_pilha']
self.epsilon = dados['epsilon']
self.inicial_pilha = dados['inicial_pilha']
self.estados_tmp = dados['estados'] ## nomes dos estados
self.estado_inicial = dados['estado_inicial']
self.estados_finais = dados['estados_finais']
self.transicoes_tmp = dados[
'transicoes'] ## dicts temporarios das transicoes
#### Atribuicao dos dados simples ####
self.estados = []
for state in self.estados_tmp: ## criar objetos de estado
estado = Estado(state)
if state == self.estado_inicial: ## setar estado inicial
self.estado_atual = estado
estado.set_inicial()
if state in self.estados_finais: ## setar estado(s) final(is)
estado.set_final()
self.estados.append(estado)
self.transicoes = []
for transition in self.transicoes_tmp: ## criar objetos de transicao
for i in self.estados:
if i.get_nome() == transition[
'estado_atual']: ## atribuir estado a transicao
cur_state = i
if i.get_nome() == transition[
'estado_destino']: ## atribuir estado a transicao
new_state = i
simbol_ent = transition['simbolo_corrente']
simbols_stack = transition['pop_pilha']
new_simbols_stack = transition['push_pilha']
## adicionar uma transicao a lista de transicoes
self.transicoes.append(
Transicao(cur_state, simbol_ent, simbols_stack, new_state,
new_simbols_stack))
## cria a primeira execucao
self.execucoes = [
Algoz(self.entrada, Pilha(self.inicial_pilha), self.estado_atual,
self.epsilon)
]
def test__eq__n_elements_stacks(self):
"""Duas pilhas com os mesmos elementos são iguais"""
x = randint(100, 500)
pilha1 = Pilha()
pilha2 = Pilha()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
pilha1.push(element)
pilha2.push(element)
self.assertEqual(pilha1, pilha2)
self.assertEqual(pilha1, pilha2)
def main():
pilha1 = Pilha()
pilha2 = Pilha()
elementosPilha1 = ['elemento1', 'elemento2', 'elemento3']
elementosPilha2 = ['elemento1', 'elemento2', 'elemento3', 'elemento4', 'elemento5']
[pilha1.pushPilha(elemento) for elemento in elementosPilha1]
[pilha2.pushPilha(elemento) for elemento in elementosPilha2]
print('Pilha 1 > Pilha 2') if testaMaisElementos(pilha1, pilha2) else print('Pilha 2 > Pilha 1')
def main():
fases = Pilha()
fase1 = Fase("Floresta", 300, -100)
fase2 = Fase("Castelo", 100, -4)
fase3 = Fase("Caverna", 400, -50)
fase4 = Fase("Guerra", 3000, -400)
fases.empila(fase1)
fases.empila(fase2)
fases.empila(fase3)
fases.empila(fase4)
falhou = fases.desempilha()
print("Falou na fase:")
print(falhou)
falhou = fases.desempilha()
print("Falou na fase:")
print(falhou)
print("Voltou para a fase")
print(fases.topo)
def __init__(self, dados):
#Abre o Arquivo
arq = open(dados[1],'r')
self.linhasArq = arq.read().splitlines()
#variaveis
self.alfaEntrada = self.linhasArq[0].split(" ")
self.alfaPilha = self.linhasArq[1].split(" ")
self.vazio = self.linhasArq[2]
self.estados = self.linhasArq[4].split(" ")
self.estadoInicial = self.linhasArq[5]
self.estadoFinal = self.linhasArq[6].split(" ")
self.transicoes = {}
self.pilhas = []
self.carrega_maquinaArquivo()
self.pilhas.append(Pilha(self.estadoInicial, list(dados[2])))
def main():
fases = Pilha()
fase1 = Fase("Floresta", 300, -100)
fase2 = Fase("Caverna", 400, -50)
fase3 = Fase("Vulcão", 300, -4)
fase4 = Fase("Montanha", 3000, -400)
fases.empilha(fase1)
fases.empilha(fase2)
fases.empilha(fase3)
fases.empilha(fase4)
falhou = fases.desempilha()
print("Falhou na fase: ")
print(falhou)
print("Voltou para a fase:")
print(fases.ver_topo)
falhou = fases.desempilha()
print("Falhou na fase: ")
print(falhou)
print("Voltou para a fase:")
print(fases.ver_topo)
def esta_balanceada(expressao):
"""
Função que calcula se expressão possui parenteses, colchetes e chaves balanceados
O Aluno deverá informar a complexidade de tempo e espaço da função
Deverá ser usada como estrutura de dados apenas a pilha feita na aula anterior
:param expressao: string com expressao a ser balanceada
:return: boleano verdadeiro se expressao está balanceada e falso caso contrário
TEMPO DE EXECUCAO:
O(n)
ESPACO DE MEMORIA:
O(n)
"""
validos = [
['(', ')'],
['[', ']'],
['{', '}']
]
pilha = Pilha()
if len(expressao) == 0:
return True
if len(expressao) == 1:
return False
for c in expressao:
for i in validos:
if c in i:
if c == i[0]:
pilha.empilhar(c)
elif pilha.vazia() or i[0] != pilha.desempilhar():
return False
return pilha.vazia()
def avaliar(expressao):
"""
Função que avalia expressão aritmetica retornando se valor se não houver nenhum erro
:param expressao: string com expressão aritmética
:return: valor númerico com resultado
tempo: O(n)
Memoria: O(n)
"""
if expressao:
fila = analise_sintatica(analise_lexica(expressao))
teste = fila.__len__()
if teste == 1:
return fila.primeiro()
else:
pilha = Pilha()
for i in range(fila.__len__()):
pilha.empilhar(fila._deque[i])
if pilha.__len__() >= 3 and str(pilha.topo()) not in '-+*/(){}[]':
valor = pilha.topo()
pilha.desempilhar()
if pilha.topo() == '+':
pilha.desempilhar()
valor = pilha.desempilhar() + valor
pilha.empilhar(valor)
valor = ''
elif pilha.topo() == '-':
pilha.desempilhar()
valor = pilha.desempilhar() - valor
pilha.empilhar(valor)
valor = ''
elif pilha.topo() == '*':
pilha.desempilhar()
valor = pilha.desempilhar() * valor
pilha.empilhar(valor)
valor = ''
elif pilha.topo() == '/':
pilha.desempilhar()
valor = pilha.desempilhar() / valor
pilha.empilhar(valor)
valor = ''
else:
pilha.empilhar(valor)
elif str(pilha.topo()) in ')}]' and i == fila.__len__() - 1:
pilha.desempilhar()
while len(pilha) > 1:
if str(pilha.topo()) not in '-+*/(){}[]':
valor = pilha.topo()
pilha.desempilhar()
if pilha.topo() == '+':
pilha.desempilhar()
valor = pilha.desempilhar() + valor
pilha.empilhar(valor)
valor = ''
elif pilha.topo() == '-':
pilha.desempilhar()
valor = pilha.desempilhar() - valor
pilha.empilhar(valor)
valor = ''
elif pilha.topo() == '*':
pilha.desempilhar()
valor = pilha.desempilhar() * valor
pilha.empilhar(valor)
valor = ''
elif pilha.topo() == '/':
pilha.desempilhar()
valor = pilha.desempilhar() / valor
pilha.empilhar(valor)
valor = ''
elif str(pilha.topo()) in '(){}[]':
pilha.desempilhar()
pilha.empilhar(valor)
else:
pilha.empilhar(valor)
else:
pilha.desempilhar()
return pilha.topo()
raise ErroSintatico()
class TestePilha(unittest.TestCase):
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.pilha_vazia = Pilha()
self.x = randint(0, maxsize)
self.pilha_um = Pilha()
self.pilha_um.push(self.x)
self.max = randint(100, 500)
self.pilha = Pilha()
self.pilha.push(self.x)
self.pilha_limite = Pilha(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.pilha_limite.push(element)
def test_construtor(self):
"""O construtor deve receber um valor max ou None"""
self.assertIsInstance(self.pilha_um, Pilha)
self.assertIsInstance(self.pilha_vazia, Pilha)
self.assertIsInstance(self.pilha, Pilha)
self.assertIsInstance(self.pilha_limite, Pilha)
def test_bool_false(self):
"""Uma Pilha Vazia retorna False"""
self.assertFalse(bool(self.pilha_vazia))
self.assertFalse(self.pilha_vazia)
self.assertFalse(self.pilha_vazia.__bool__())
def test_bool_true(self):
"""Uma Pilha com 1 elemento retorna True"""
self.assertTrue(bool(self.pilha_um))
self.assertTrue(self.pilha_um)
self.assertTrue(self.pilha_um.__bool__())
def test_empty_stack(self):
"""Uma Pilha Vazia retorna True para is_empty"""
self.assertTrue(self.pilha_vazia.is_empty())
def test_not_empty_stack(self):
"""Uma Pilha Não Vazia retorna False para is_empty"""
self.assertFalse(self.pilha_um.is_empty())
def test_len_empty_stack(self):
"""Uma Pilha Vazia tem tamanho 0"""
self.assertEqual(len(self.pilha_vazia), 0)
def test_len_one_element_stack(self):
"""Uma Pilha com 1 elemento tem tamanho 1"""
self.assertEqual(len(self.pilha_um), 1)
#Este Teste só funciona quando push tiver sido implementado
def test_len_arbitrary_size_stack(self):
"""Uma Pilha com n elementos tem tamanho n"""
self.assertEqual(len(self.pilha_limite), self.max)
def test_peek_empty_stack(self):
"""Uma Pilha vazia retorna uma Exceção quando peek é invocado"""
with self.assertRaises(Exception):
self.pilha_vazia.peek()
def test_peek_one_element_stack(self):
"""Uma Pilha com 1 elemento retorna o elemento com peek"""
self.assertEqual(self.pilha_um.peek(), self.x)
def test_peek_n_elements_stack(self):
"""Uma Pilha com n elementos retorna o último a ter sido inserido com peek"""
self.assertEqual(self.pilha_limite.peek(), self.python_deque.pop())
def test_peek_doesnt_change_stack_len(self):
"""O método peek é idempotente e não altera o tamanho da pilha"""
size = len(self.pilha_limite)
self.assertEqual(len(self.pilha_limite), size)
self.pilha_limite.peek()
self.pilha_limite.peek()
self.pilha_limite.peek()
self.pilha_limite.peek()
self.pilha_limite.peek()
self.assertEqual(len(self.pilha_limite), size)
def test__eq__empty_stacks(self):
"""Duas pilhas vazias são iguais"""
self.assertEqual(Pilha(), Pilha())
#o argumento é a capacidade da pilha
self.assertEqual(Pilha(5), Pilha(10))
def test__eq__n_elements_stacks(self):
"""Duas pilhas com os mesmos elementos são iguais"""
x = randint(100, 500)
pilha1 = Pilha()
pilha2 = Pilha()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
pilha1.push(element)
pilha2.push(element)
self.assertEqual(pilha1, pilha2)
self.assertEqual(pilha1, pilha2)
def test_str_empty_stack(self):
"""Uma pilha vazia deve ser representada pela string []"""
self.assertEqual(str(self.pilha_vazia), "[]")
def test_str_one_element_stack(self):
"""Uma pilha com somente um elemento x deve ser representada por [x]"""
self.assertEqual(str(self.pilha_um), "[" + str(self.x) + "]")
def test_str_n_elements_stack(self):
"""Uma pilha com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no começo,
mas também é possível inserir no final e retirar no final"""
pilha = Pilha()
pilha.push(1)
pilha.push(2)
pilha.push(3)
pilha.push(4)
self.assertEqual(str(pilha), "[4, 3, 2, 1]")
def test_clear_remove_all_elements(self):
"""clear remove todos os elementos da pilha"""
self.assertEqual(len(self.pilha_vazia), 0)
self.assertNotEqual(len(self.pilha_um), 0)
self.assertNotEqual(len(self.pilha_limite), 0)
self.pilha_vazia.clear()
self.pilha_um.clear()
self.pilha_limite.clear()
self.assertEqual(len(self.pilha_vazia), 0)
self.assertEqual(len(self.pilha_um), 0)
self.assertEqual(len(self.pilha_limite), 0)
def test_push(self):
"""push aumenta o tamanho da pilha em 1"""
element = randint(0, self.MAX_VALUE)
self.assertEqual(len(self.pilha_vazia), 0)
self.assertEqual(len(self.pilha_um), 1)
self.pilha_vazia.push(element)
self.pilha_um.push(element)
self.assertEqual(len(self.pilha_vazia), 1)
self.assertEqual(len(self.pilha_um), 2)
def test_push_full_stack(self):
"""push numa pilha cheia gera um erro"""
with self.assertRaises(Exception):
element = randint(0, self.MAX_VALUE)
self.pilha_limite.push(element)
def test_pop(self):
"""pop diminui o tamanho da pilha em 1"""
self.assertEqual(len(self.pilha_um), 1)
self.pilha_um.pop()
self.assertEqual(len(self.pilha_um), 0)
self.assertEqual(self.pilha_um, Pilha())
size = len(self.pilha_limite)
self.pilha_limite.pop()
self.assertEqual(len(self.pilha_limite), size - 1)
def test_pop_empty_stack(self):
"""pop numa pilha vazia gera um erro"""
with self.assertRaises(Exception):
self.pilha_vazia.pop()
def test_push_pop_1(self):
"""teste de integração pipeline de pilhas"""
pilha1 = Pilha()
pilha2 = Pilha()
pilha3 = Pilha()
pilha4 = Pilha()
for i in range(0, self.max):
pilha1.push(i)
pilha2.push(pilha1.pop())
pilha3.push(pilha2.pop())
pilha4.push(pilha3.pop())
self.assertEqual(i, pilha4.pop())
def test_desempilhar_pilha_vazia(self): p = Pilha() self.assertTrue(p.pilhaVazia()) p.desempilha() self.assertFalse(p.desempilha())
def test_pilha_vazia(self): p = Pilha() self.assertTrue(p.pilhaVazia()) self.assertEqual(p.tamanho(), 0)
def test_push_pop_1(self):
"""teste de integração pipeline de pilhas"""
pilha1 = Pilha()
pilha2 = Pilha()
pilha3 = Pilha()
pilha4 = Pilha()
for i in range(0, self.max):
pilha1.push(i)
pilha2.push(pilha1.pop())
pilha3.push(pilha2.pop())
pilha4.push(pilha3.pop())
self.assertEqual(i, pilha4.pop())
from pilha import Pilha stack = Pilha() stack.push(1) stack.push(Pilha) stack.push(5) stack.pop() #stack.clean() print(stack)
def _given_uma_pilha(context):
context.pilha = Pilha(10)
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 ?'))
def test__eq__empty_stacks(self):
"""Duas pilhas vazias são iguais"""
self.assertEqual(Pilha(), Pilha())
#o argumento é a capacidade da pilha
self.assertEqual(Pilha(5), Pilha(10))
def ordenar(self):
stack = Pilha()
stack2 = Pilha()
while self.inicio is not None:
if stack.consultar() is None:
stack.inserir(self.inicio.dado)
self.excluir()
else:
while self.inicio.dado > stack.consultar():
stack2.inserir(stack.consultar())
stack.remover()
if stack.consultar() is None:
break
stack.inserir(self.inicio.dado)
self.excluir()
while stack2.consultar() is not None:
stack.inserir(stack2.consultar())
stack2.remover()
while stack.consultar() is not None:
self.inserir(stack.consultar())
stack.remover()
return self.mostrar_fila()
from pilha import Pilha
from tkinter import *
p1 = Pilha()
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)
def __init__(self, max_elementos):
self.__pilha = Pilha()
self.__fila = Fila()
self.__max_elementos = max_elementos
def _when_crio_pilha(context):
context.pilha = Pilha(context.tam)
def main():
pilhaTeste = Pilha()
pilhaTeste.push("Teste")
pilhaTeste.push("Teste2")
print(pilhaTeste)
pilhaTeste.pop()
print(pilhaTeste)
nome = input("Digite o nome do usuario completo: ")
for n in nome.split(" "):
pilhaTeste.push(n.strip())
print(pilhaTeste)
pilhaTeste.pop()
print(pilhaTeste)
print(pilhaTeste.topo())
pilhaTeste.esvaziar()
from pilha import Pilha
file = open('teste.txt', 'r')
p = Pilha()
def matches(ope, close):
opens = [
'<html>', '<body>', '<head>', '<title>', '<center>', '<h1>', '<p>',
'<ol>', '<li>'
]
closes = [
'</html>', '</body>', '</head>', '</title>', '</center>', '</h1>',
'</p>', '</ol>', '</li>'
]
# verifica se o indice da tag que abre corresponde à que fecha
return opens.index(ope) == closes.index(close)
balanced = True
search = file.read()
# lista com tadas as palavras do texto
searchlist = search.split()
for word in searchlist:
# print(i)
# se a palavra não começar com '</' então é tag de entrada
if word[0] == "<" and word[1] != "/":
# adiciona a pilha
p.push(word)
elif word[0] == "<" and word[1] == "/":
from pilha import Pilha
import automato as atm
flag = "exit"
while (1):
word = input("palavra: ")
if word == flag:
break
else:
pilha = Pilha()
atm.start(word, len(word), pilha)
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())
e.remover(2)
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('======================================')
def test_push_pop_1(self):
"""teste de integração pipeline de pilhas"""
pilha1 = Pilha()
pilha2 = Pilha()
pilha3 = Pilha()
pilha4 = Pilha()
for i in range(0, self.max):
pilha1.push(i)
pilha2.push(pilha1.pop())
pilha3.push(pilha2.pop())
pilha4.push(pilha3.pop())
self.assertEqual(i, pilha4.pop())
class TestePilha(unittest.TestCase):
def setUp(self):
"""Esse método é invocado antes de cada Teste. Prepara o ambiente"""
self.MAX_VALUE = 10000
self.pilha_vazia = Pilha()
self.x = randint(0, maxsize)
self.pilha_um = Pilha()
self.pilha_um.push(self.x)
self.max = randint(100, 500)
self.pilha = Pilha()
self.pilha.push(self.x)
self.pilha_limite = Pilha(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.pilha_limite.push(element)
def test_construtor(self):
"""O construtor deve receber um valor max ou None"""
self.assertIsInstance(self.pilha_um, Pilha)
self.assertIsInstance(self.pilha_vazia, Pilha)
self.assertIsInstance(self.pilha, Pilha)
self.assertIsInstance(self.pilha_limite, Pilha)
def test_bool_false(self):
"""Uma Pilha Vazia retorna False"""
self.assertFalse(bool(self.pilha_vazia))
self.assertFalse(self.pilha_vazia)
self.assertFalse(self.pilha_vazia.__bool__())
def test_bool_true(self):
"""Uma Pilha com 1 elemento retorna True"""
self.assertTrue(bool(self.pilha_um))
self.assertTrue(self.pilha_um)
self.assertTrue(self.pilha_um.__bool__())
def test_empty_stack(self):
"""Uma Pilha Vazia retorna True para is_empty"""
self.assertTrue(self.pilha_vazia.is_empty())
def test_not_empty_stack(self):
"""Uma Pilha Não Vazia retorna False para is_empty"""
self.assertFalse(self.pilha_um.is_empty())
def test_len_empty_stack(self):
"""Uma Pilha Vazia tem tamanho 0"""
self.assertEqual(len(self.pilha_vazia), 0)
def test_len_one_element_stack(self):
"""Uma Pilha com 1 elemento tem tamanho 1"""
self.assertEqual(len(self.pilha_um), 1)
# Este Teste só funciona quando push tiver sido implementado
def test_len_arbitrary_size_stack(self):
"""Uma Pilha com n elementos tem tamanho n"""
self.assertEqual(len(self.pilha_limite), self.max)
def test_peek_empty_stack(self):
"""Uma Pilha vazia retorna uma Exceção quando peek é invocado"""
with self.assertRaises(Exception):
self.pilha_vazia.peek()
def test_peek_one_element_stack(self):
"""Uma Pilha com 1 elemento retorna o elemento com peek"""
self.assertEqual(self.pilha_um.peek(), self.x)
def test_peek_n_elements_stack(self):
"""Uma Pilha com n elementos retorna o último a ter sido inserido com peek"""
self.assertEqual(self.pilha_limite.peek(), self.python_deque.pop())
def test_peek_doesnt_change_stack_len(self):
"""O método peek é idempotente e não altera o tamanho da pilha"""
size = len(self.pilha_limite)
self.assertEqual(len(self.pilha_limite), size)
self.pilha_limite.peek()
self.pilha_limite.peek()
self.pilha_limite.peek()
self.pilha_limite.peek()
self.pilha_limite.peek()
self.assertEqual(len(self.pilha_limite), size)
def test__eq__empty_stacks(self):
"""Duas pilhas vazias são iguais"""
self.assertEqual(Pilha(), Pilha())
# o argumento é a capacidade da pilha
self.assertEqual(Pilha(5), Pilha(10))
def test__eq__n_elements_stacks(self):
"""Duas pilhas com os mesmos elementos são iguais"""
x = randint(100, 500)
pilha1 = Pilha()
pilha2 = Pilha()
for i in range(0, x):
element = randint(0, self.MAX_VALUE)
pilha1.push(element)
pilha2.push(element)
self.assertEqual(pilha1, pilha2)
self.assertEqual(pilha1, pilha2)
def test_str_empty_stack(self):
"""Uma pilha vazia deve ser representada pela string []"""
self.assertEqual(str(self.pilha_vazia), "[]")
def test_str_one_element_stack(self):
"""Uma pilha com somente um elemento x deve ser representada por [x]"""
self.assertEqual(str(self.pilha_um), "[" + str(self.x) + "]")
def test_str_n_elements_stack(self):
"""Uma pilha com n elementos imprime todos os elementos"""
"""Nossa implementação insere no começo e retira no começo,
mas também é possível inserir no final e retirar no final"""
pilha = Pilha()
pilha.push(1)
pilha.push(2)
pilha.push(3)
pilha.push(4)
self.assertEqual(str(pilha), "[4, 3, 2, 1]")
def test_clear_remove_all_elements(self):
"""clear remove todos os elementos da pilha"""
self.assertEqual(len(self.pilha_vazia), 0)
self.assertNotEqual(len(self.pilha_um), 0)
self.assertNotEqual(len(self.pilha_limite), 0)
self.pilha_vazia.clear()
self.pilha_um.clear()
self.pilha_limite.clear()
self.assertEqual(len(self.pilha_vazia), 0)
self.assertEqual(len(self.pilha_um), 0)
self.assertEqual(len(self.pilha_limite), 0)
def test_push(self):
"""push aumenta o tamanho da pilha em 1"""
element = randint(0, self.MAX_VALUE)
self.assertEqual(len(self.pilha_vazia), 0)
self.assertEqual(len(self.pilha_um), 1)
self.pilha_vazia.push(element)
self.pilha_um.push(element)
self.assertEqual(len(self.pilha_vazia), 1)
self.assertEqual(len(self.pilha_um), 2)
def test_push_full_stack(self):
"""push numa pilha cheia gera um erro"""
with self.assertRaises(Exception):
element = randint(0, self.MAX_VALUE)
self.pilha_limite.push(element)
def test_pop(self):
"""pop diminui o tamanho da pilha em 1"""
self.assertEqual(len(self.pilha_um), 1)
self.pilha_um.pop()
self.assertEqual(len(self.pilha_um), 0)
self.assertEqual(self.pilha_um, Pilha())
size = len(self.pilha_limite)
self.pilha_limite.pop()
self.assertEqual(len(self.pilha_limite), size - 1)
def test_pop_empty_stack(self):
"""pop numa pilha vazia gera um erro"""
with self.assertRaises(Exception):
self.pilha_vazia.pop()
def test_push_pop_1(self):
"""teste de integração pipeline de pilhas"""
pilha1 = Pilha()
pilha2 = Pilha()
pilha3 = Pilha()
pilha4 = Pilha()
for i in range(0, self.max):
pilha1.push(i)
pilha2.push(pilha1.pop())
pilha3.push(pilha2.pop())
pilha4.push(pilha3.pop())
self.assertEqual(i, pilha4.pop())
