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 __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(): 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('======================================')
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())