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 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_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 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 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_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_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 main():
pilha = Pilha()
pilha1 = [
"Esta",
"pilha",
"não",
"é",
"maior",
]
pilha2 = ["do", "que", "esta", "pilha", "aqui", "xD"]
print(pilha.testaMaisElementos(pilha1, pilha2))
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()
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 __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 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()
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 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 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)
from pilha import Pilha stack = Pilha() stack.push(1) stack.push(Pilha) stack.push(5) stack.pop() #stack.clean() print(stack)
def test_adicionando():
s = Pilha()
s.push(2)
assert 2 in s
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)
def analisa(self):
p = Pilha()
p.empilha("$")
p.empilha("<start>")
tabela = GeraTabelaSintatica()
tabela.gerar_tabela()
# Abre o arquivo de saida do programa
arquivo_saida = open(self.arquivo_saida, 'w')
# Verifica se o arquivo de entrada existe no diretorio em questao
if not os.path.exists(self.arquivo_entrada):
arquivo_saida.write("Arquivo de entrada inexistente")
return
# Abre o arquivo de entrada do programa
arquivo = open(self.arquivo_entrada, 'r')
# Le o primeiro token
linha_list_tok = arquivo.readline()
# Variavel que indica o token_atual
token_linha = linha_list_tok.split(' ')
token_atual = token_linha[1]
# Percorre o programa linha por linha
while linha_list_tok:
if (token_linha[0] == "tok500"):
token_atual = token_linha[0]
#print(token_atual)
elif (token_linha[0] == "tok300"):
token_atual = token_linha[0]
#print(token_atual)
elif (token_linha[0] == "tok400"):
token_atual = token_linha[0]
#print(token_atual)
elif (token_linha[0] == "tok700"):
token_atual = token_linha[0]
#print(token_atual)
else:
token_atual = token_linha[1].replace("\n", "")
#print(token_atual)
prod_topo_pilha = p.desempilha()
while (token_atual != prod_topo_pilha):
producoes = tabela.consultar_tabela_sintatica(
prod_topo_pilha, token_atual)
print(producoes)
if (producoes[0] != "$"):
for prod in range(len(producoes)):
p.empilha(producoes[prod])
elif producoes[0] == "x":
print("Erro sintatico")
break
prod_topo_pilha = p.desempilha()
linha_list_tok = arquivo.readline() # Le proximo token
token_linha = linha_list_tok.split(' ')
if (len(token_linha) == 2):
token_atual = token_linha[1]
# Fim do arquivo de entrada
arquivo.close()
# Fim do arquivo de entrada
arquivo_saida.close
def before():
s = Pilha()
return s
def _when_crio_pilha(context):
context.pilha = Pilha(context.tam)
from pilha import Pilha p = Pilha() #print(p.peek()) p.push(5) p.push(3) print(p) p.pop() print(p.peek()) p.pop() p.push(9) p.push(1) print(p) print(p.peek()) p.push(4) p.pop() p.pop() print(p) p1 = Pilha() p1.push(1) p1.push(2) p1.push(3) p2 = Pilha() p2.push(1) p2.push(3) p2.push(3) print(p1.equal(p2))
def _given_uma_pilha(context):
context.pilha = Pilha(10)
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 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 ?'))
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
