def __init__(self):
self.__pilha = Pilha()
self.__fila = Fila()
self.__limitepilha = 5
self.__limitefila = 5
self.__contadorpilha = 0
self.__contadorfila = 0
def __init__(self, n):
self.nxt = [0] * n
self.key = [0] * n
self.prv = [0] * n
self.s = Pilha(n)
for k in range(0, n):
self.s.push(k)
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
class Busca_Em_Profundidade_Visitados:
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
#fronteira armazena pilha de cidades que serão visitadas
self.fronteira = Pilha(1000)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print("Topo: {}".format(topo.nome))
if topo == self.objetivo:
print("Objetivo {}" .format(self.objetivo.nome), "foi alcançado apartir de {}" .format(self.inicio.nome))
self.achou = True
else:
for adjacente in topo.adjacentes:
if self.achou == False:
print("Verificando se ja visitado: {}".format(adjacente.cidade.nome))
if adjacente.cidade.visitado == False:
adjacente.cidade.visitado = True
self.fronteira.empilhar(adjacente.cidade)
Busca_Em_Profundidade_Visitados.buscar(self)
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
#fronteira armazena pilha de cidades que serão visitadas
self.fronteira = Pilha(1000)
self.fronteira.empilhar(inicio)
self.achou = False
def __init__(self, n):
self.p = [0] * n
self.key = [0] * n
self.left = [0] * n
self.right = [0] * n
self.s = Pilha(n)
for k in range(0, n):
self.s.push(k)
class Baralho:
"""Classe que manipula um baralho francês de 52 cartas"""
def __init__(self):
self.baralho = []
self.naipes = ['copas', 'espadas', 'ouros', 'paus']
self.embalharada = None
self.pilha = Pilha()
def gerar_baralho(self):
"""Gera um baralho de 52 cartas, divididas em 4 naipes. as cartas são representadas por
um vetor [a, b, c], sendo: a = inteiro representando o valor numerico da carta; b = string
representando o valor facial da carta; c = string representando o naipe da carta. Matriz 52x3"""
for i in self.naipes:
for j in range(2, 12):
if j < 10:
self.baralho.append([j, str(j), i])
elif j == 10:
self.baralho.append([j, str(j), i])
self.baralho.append([j, "Q", i])
self.baralho.append([j, "J", i])
self.baralho.append([j, "K", i])
elif j == 11:
self.baralho.append([j, "A", i])
def mostrar_baralho(self):
"""Retorna a matriz contendo o baralho"""
return self.baralho
def fisher_yates_shuffle(self, vet_ordenado):
"""Implementa o algoritmo avançado Fisher Yates Shuffle. Esse algoritmo embaralha os itens
de uma sequencia finita (vetor) e a retorna"""
rand = RandInt()
vetor_ordenado = [i for i in vet_ordenado]
a = len(vetor_ordenado)
b = a - 1
for d in range(b, 0, -1):
e = rand.numero_aleatorio(d)
if e == d:
continue
vetor_ordenado[d], vetor_ordenado[e] = vetor_ordenado[
e], vetor_ordenado[d]
self.embalharada = vetor_ordenado
return vetor_ordenado
def pilha_embaralhar(self):
"""Embaralha a pilha de cartas"""
self.fisher_yates_shuffle(self.baralho)
for j in range(len(self.embalharada)):
self.pilha.empilha(
self.embalharada[j]) # Empilhando o baralho dentro da pilha.
return self.pilha
def topo_da_pilha(self):
"""Retira o topo da pilha e o retorna"""
self.embalharada.pop(
) # só para ficar igual a pilha de estrutura de dados...
return self.pilha.desempilha(
) # retira o topo da pilha, usando função desempilha() da classe Pilha.
def dfs(grafo,alvo):
p = Pilha(grafo)
while not p.vazia():
if visitado(alvo):
return alvo
atual = p.vertice_atual()
foivisitado(atual)
arestas_vertices = p.desempilha()
for aresta_vertice in arestas_vertices:
if not visitado(aresta_vertice):
foivisitado(aresta_vertice)
class Memoria:
p = []
key = []
left = []
right = []
NIL = 0
def __getitem__(self, index):
return self.s[index]
def __init__(self, n):
self.p = [0] * n
self.key = [0] * n
self.left = [0] * n
self.right = [0] * n
self.s = Pilha(n)
for k in range(0, n):
self.s.push(k)
def allocate_object(self):
x = self.s.pop()
if x == 0:
return 0
else:
return x
def free_object(self, x):
self.s.push(x)
def toString(self):
res = StringIO()
for k in range((len(self.p)) - 1, -1, -1):
res.write("{}".format(k))
res.write("-> [p = ")
res.write("nil") if self.p[k] == 0 else res.write("{}".format(self.p[k]))
res.write(", key = ")
res.write("{}".format(self.key[k]))
res.write(", left = ")
res.write("nil") if self.left[k] == 0 else res.write("{}".format(self.left[k]))
res.write(", right = ")
res.write("nil") if self.right[k] == 0 else res.write("{}".format(self.right[k]))
res.write("]\n")
return res.getvalue()
class Profundidade:
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo: {}'.format(topo.nome))
if topo == self.objetivo:
self.achou = True
else:
'''For para percorrer todos os vertices do topo'''
for a in topo.adjacentes:
if self.achou == False:
print('Verificando se já visitado: {}'.format(
a.cidade.nome))
if a.cidade.visitado == False:
a.cidade.visitado = True
self.fronteira.empilhar(a.cidade)
Profundidade.buscar(self)
print('Desempilhou: {}'.format(self.fronteira.desempilhar().nome))
class Profundidade:
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo: {}'.format(topo.nome))
if (topo == self.objetivo):
self.achou = True
else:
for a in topo.adjacentes:
if self.achou == False:
print('verificando se ja visitado: {}'.format(
a.cidade.nome))
if (a.cidade.visitado == False):
a.cidade.visitado = True
self.fronteira.empilhar(a.cidade)
Profundidade.buscar(self)
print('desempilhou:{}'.format(self.fronteira.desempilhar().nome))
class Backtracking:
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
self.fronteira = Pilha(16)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo {}'.format(topo.nome))
if topo == self.objetivo:
self.achou = True
print('Objetivo alcançado!')
else:
for a in topo.adjacentes:
if self.achou == False:
if a.letras.visitado == False:
a.letras.visitado = True
print('Estado visitado: {}'.format(a.letras.nome))
self.fronteira.empilhar(a.letras)
Backtracking.buscar(self)
print('Desempilhou: {}'.format(self.fronteira.desempilhar().nome))
class Profundidade:
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo: {}'.format(topo.nome))
if topo == self.objetivo:
self.achou = True
return print('A cidade {}'.format(topo.nome)+' foi encontrada!')
else:
for a in topo.adjacentes:
if self.achou == False:
print('Verificando se já visitado: {}'.format(a.cidade.nome))
if a.cidade.visitado == False:
a.cidade.visitado = True
self.fronteira.empilhar(a.cidade)
Profundidade.buscar(self)
print('Desempilhou: {}'.format(self.fronteira.desempilhar().nome))
class Backtracking:
def __init__(self, inicio, objetivo):
self.inicio = inicio
self.inicio.visitado = True
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo: {}'.format(topo.nome))
if topo == self.objetivo:
self.achou = True
else:
'''For para percorrer todos os vertices do topo'''
for a in topo.adjacentes:
if self.achou == False:
print('Estado a ser visitado: {}'.format(a.Letras.nome))
if a.Letras.visitado == False:
a.Letras.visitado = True
self.fronteira.empilhar(a.Letras)
Backtracking.buscar(self)
print('Desempilhou: {}'.format(self.fronteira.desempilhar().nome))
def main():
pilha = Pilha()
pilha.empilhar('A')
pilha.empilhar('B')
pilha.empilhar('C')
pilha.empilhar('D')
while (not pilha.estaVazia()):
print('Elemento da PILHA: ' + pilha.desempilhar())
print('---------------------------------------')
fila = Fila()
fila.inserir('A')
fila.inserir('B')
fila.inserir('C')
fila.inserir('D')
while (not fila.estaVazia()):
print('Elemento da FILA: ' + fila.remover())
class MemoriaLL:
nxt = []
key = []
prv = []
def __getitem__(self, index):
return self.s[index]
def __setitem__(self, key, item):
self.s[key] = item
def __init__(self, n):
self.nxt = [0] * n
self.key = [0] * n
self.prv = [0] * n
self.s = Pilha(n)
for k in range(0, n):
self.s.push(k)
def allocate_object(self):
x = self.s.pop()
if x == 0:
return 0
else:
return x
def free_object(self, x):
self.s.push(x)
def toString(self):
res = StringIO()
for k in range(0, self.s.size()):
res.write("{}".format(k))
res.write("-> [")
res.write("{}".format(self.prv[k]))
res.write(", ")
res.write("{}".format(self.key[k]))
res.write(", ")
res.write("{}".format(self.nxt[k]))
res.write("]\n")
return res.getvalue()
class ControladorPrincipal:
def __init__(self):
self.__pilha = Pilha()
self.__fila = Fila()
self.__limitepilha = 5
self.__limitefila = 5
self.__contadorpilha = 0
self.__contadorfila = 0
def inicia(self):
print("")
print("Escolha uma das opcoes:")
print("---------- OPCOES ----------")
print("1 - Add(Push) na Pilha")
print("2 - Excluir(Pop) na Pilha")
print("3 - Add(Enqueue) na Fila")
print("4 - Excluir(Dequeue) na Fila")
print("5 - Para escolher o limite de valores.")
print("6 - Ver Topo da Pilha.")
print("7 - Ver Inicio e Fim da Fila.")
escolha = int(input("Digite o numero de uma das opcoes:"))
print("")
if escolha == 1:
self.add_pilha(
float(input("Digite um valor para adicionar na pilha:")))
self.inicia()
if escolha == 2:
self.remove_pilha()
self.inicia()
if escolha == 3:
self.add_fila(
float(input("Digite um valor para adicionar na fila:")))
self.inicia()
if escolha == 4:
self.remove_fila()
self.inicia()
if escolha == 5:
self.definir_limite()
self.inicia()
if escolha == 6:
print("Valor no Topo da Pilha: " + str(self.__pilha.top()))
self.inicia()
if escolha == 7:
print("Inicio da Fila: " + str(self.__fila.head()) +
" Fim da Fila: " + str(self.__fila.tail()))
self.inicia()
def add_pilha(self, valor):
if int(self.__contadorpilha) >= int(self.__limitepilha):
print(
"Impossivel adicionar um valor, pilha cheia. Por favor remova um valor antes de adicionar outro."
)
else:
self.__pilha.push(valor)
self.__contadorpilha += 1
print("Valor " + str(valor) + " adicionado a pilha.")
def remove_pilha(self):
if self.__pilha.vazia():
print("Impossivel remover um valor, pilha vazia.")
else:
self.__pilha.pop()
self.__contadorpilha -= 1
print("Valor no topo da Pilha removido.")
def add_fila(self, valor):
if int(self.__contadorfila) >= int(self.__limitefila):
print(
"Impossivel adicionar um valor, fila cheia. Por favor remova um valor antes de adicionar outro."
)
else:
self.__fila.enqueue(valor)
self.__contadorfila += 1
print("Valor " + str(valor) + " adicionado a fila.")
def remove_fila(self):
if self.__fila.vazia():
print("Impossivel remover um valor, fila vazia.")
else:
self.__fila.dequeue()
self.__contadorfila -= 1
print("Primeiro da fila removido.")
def definir_limite(self):
escolha = input(
"Para definir o limite da pilha ou da fila digite: 1 para Pilha ou 2 para Fila"
)
if int(escolha) == 1:
self.__limitepilha = input(
"Digite um inteiro para ser o limite de valores da pilha.")
if int(escolha) == 2:
self.__limitefila = input(
"Digite um inteiro para ser o limite de valores da fila.")
def top(self):
return self.__pilha.top()
def head(self):
return self.__fila.head()
def tail(self):
return self.__fila.tail()
from Pilha import Pilha
Pilha = Pilha()
menu = '''
---------------
MENU
1 - Adicionar
2 - Remover
3 - Imprmir
4 - Sair
---------------
Escolha: '''
while True:
digito = (input(menu))
if digito == '1':
Pilha.addpilha(input('Digite um valor: '))
elif digito == '2':
Pilha.remover()
elif digito == '3':
Pilha.imprimirpilha()
elif digito == '4':
print("Concluído")1
break
else:
print('Tente novamente')
class Advogado:
def __init__(self, cod_oab):
self._cod_oab = cod_oab
self._processosL = Lista()
self._processosP = Pilha()
self._processosF = Fila()
# GETTER AND SETTERS
def get_cod_oab(self):
return self._cod_oab
def set_cod_oab(self, novo_cod_oab):
self._cod_oab = novo_cod_oab
def get_processosP(self):
return self._processosP
def get_processosF(self):
return self._processosF
def get_processosL(self):
return self._processosL
# OUTROS METODOS - LISTA
def maior_custo(self):
return self._processosL.maior_custo()
def menor_custo(self):
return self._processosL.menor_custo()
def incrementa_custo_processo(self, cod, valor):
processo = self._processosL.buscar_processo(cod)
processo.incrementa_custo(valor)
def busca_processo(self, cod):
processo = self.get_processosL().buscar_processo(cod)
return processo
def ordena_processos(self):
return self._processosL.ordenar()
def imprimir_processos(self):
return self._processosL.imprimir_processos()
def adicionar_processo_L(self, processo, posicao):
self._processosL.adicionar(processo, posicao)
def remover_processo_L(self, posicao):
return self._processosL.remover(posicao)
def mostrar_tam_processosL(self):
return self._processosL.tamanho()
# OUTROS METODOS - PILHA
def adicionar_processo_P(self, processo):
self._processosP.adicionar(processo)
def remover_processo_P(self):
self._processosP.remover()
def mostrar_tam_processosP(self):
return self._processosP.tamanho()
# OUTROS METODOS - FILA
def adicionar_processo_F(self, processo):
self._processosF.adicionar(processo)
def remover_processo_F(self):
self._processosF.remover()
def mostrar_tam_processosF(self):
return self._processosF.tamanho()
def __str__(self):
return f'Advogado OAB: {self.get_cod_oab()}\n\nProcessos Penais (ProcessosP):\n\n{self.get_processosP().imprimir()}\n\n\nProcessos Trabalhistas (ProcessosF):\n\n{self.get_processosF().imprimir()}\n\n\nProcessos Cíveis (ProcessosL):\n\n{self.get_processosL().imprimir()}\n\n'
# if __name__ == '__main__':
# print(advogado1.get_processosF().imprimir())
# print(advogado1.get_processosP().imprimir())
# print(advogado1.get_processosL().imprimir())
# print(advogado1.get_processosP())
# safado = Advogado("01")
# safado.adicionar_processo_L("Calunia", "1000", "favoravel", "finalizado", "005", 1)
# safado.adicionar_processo_L("Calunia", "1000", "favoravel", "finalizado", "004", 2)
# safado.adicionar_processo_L("Calunia", "1000", "favoravel", "finalizado", "003", 3)
# safado.adicionar_processo_L("Calunia", "1000", "favoravel", "finalizado", "001", 4)
# safado.adicionar_processo_L("Calunia", "1000", "favoravel", "finalizado", "002", 5)
# print(safado.mostrar_tam_processosL())
# print(safado.imprimir_processos())
# safado.ordena_processos()
# print(safado.imprimir_processos())
# safado.remover_processo_P()
# print(safado.mostrar_tam_processosP())
# print(safado.get_processosP())
# print(safado.mostrar_tam_processosL())
def __init__(self):
self.baralho = []
self.naipes = ['copas', 'espadas', 'ouros', 'paus']
self.embalharada = None
self.pilha = Pilha()
from Pilha import Pilha
pilha = Pilha()
pilha.imprimir()
pilha.adicionar("Computador")
pilha.imprimir()
pilha.adicionar("Notebook")
pilha.imprimir()
pilha.empilhar("Tablet")
pilha.empilhar("Smartphone")
pilha.imprimir()
print("---- Removendo ----")
pilha.remover()
pilha.adicionar("Relógio")
pilha.imprimir()
pilha.remover()
pilha.remover()
pilha.remover()
pilha.remover()
from Pilha import Pilha
print("Cria a pilha")
pilha = Pilha()
pilha.push(1)
pilha.push(2)
pilha.push(3)
pilha.push(4)
print(pilha)
print(pilha.pop())
print(pilha.pop())
print(pilha.pop())
print(pilha.pop())
class Campeonato:
def __init__(self, nome_do_campeonato):
self._nome_do_campeonato = nome_do_campeonato
self._surfistasP = Pilha()
self._surfistasF = Fila()
self._surfistasL = Lista()
@property
def nome(self):
return self._nome_do_campeonato
@nome.setter
def nome(self, novo_nome):
self._nome_do_campeonato = novo_nome
@property
def surfistasL(self):
return self._surfistasL
@surfistasL.setter
def surfistasL(self, novo):
self._surfistasL = novo
@property
def surfistasP(self):
return self._surfistasP
@surfistasP.setter
def surfistasP(self, novo):
self._surfistasP = novo
@property
def surfistasF(self):
return self._surfistasF
@surfistasF.setter
def surfistasF(self, novo):
self._surfistasF = novo
def menor_idade(self):
if (self._surfistasL.Tamanho() == 0):
raise CampeonatoException(
'Não há surfistas na lista do campeonato.')
aux = self._surfistasL.Inicio
nome = aux.nome
menor = aux.idade
while (aux != None):
if aux.idade < menor:
menor = aux.idade
nome = aux.nome
aux = aux.prox
return nome
def maior_idade(self):
if (self._surfistasL.Tamanho() == 0):
raise CampeonatoException(
'Não há surfistas na lista do campeonato.')
aux = self._surfistasL.Inicio
maior = aux.idade
nome = aux.nome
while (aux != None):
if aux.idade > maior:
maior = aux.idade
nome = aux.nome
aux = aux.prox
return nome
def incrementa_titulo_surfista(self, cpf):
if (self._surfistasL.Tamanho() == 0):
raise CampeonatoException(
'Não há surfistas na lista do campeonato.')
surfista = self._surfistasL.Buscar(cpf)
surfista.incrementa_titulo()
def adicionar_surfistas_P(self, novo_surfista):
self._surfistasP.Adicionar(novo_surfista)
def remover_surfista_P(self):
self._surfistasP.Remover()
def mostrar_tam_surfistasP(self):
return self._surfistasP.Tamanho()
def busca_surfista_P(self):
return self.surfistasP.MostrarElemento()
def adicionar_surfistas_F(self, novo_surfista):
self._surfistasF.Adicionar(novo_surfista)
def remover_surfista_F(self):
self._surfistasF.Remover()
def mostrar_tam_surfistasF(self):
return self.surfistasF.Tamanho()
def busca_surfista_F(self):
return self.surfistasF.MostrarElemento()
def adicionar_surfistas_L(self, novo_surfista, posicao=-1):
self._surfistasL.Adicionar(novo_surfista, posicao)
def remover_surfista_L(self, posicao):
self._surfistasL.Remover(posicao)
def mostrar_tam_surfistasL(self):
return self._surfistasL.Tamanho()
def mostrar_tam_total(self):
return self.mostrar_tam_surfistasL() + self.mostrar_tam_surfistasF(
) + self.mostrar_tam_surfistasP()
def busca_surfista(self, cpf):
return self._surfistasL.Buscar(cpf)
def ordena_surfistas(self):
self._surfistasL.Ordenar()
def imprimir_surfistas(
self
): #imprimir_surfistas() - imprime na tela os surfistas em surfistasL: “nome –titulos”;
return self._surfistasL.Imprimir()
def __str__(self):
return f'Nome do Campeonato: {self._nome_do_campeonato}'
def __init__(self, cod_oab):
self._cod_oab = cod_oab
self._processosL = Lista()
self._processosP = Pilha()
self._processosF = Fila()
from Pilha import Pilha
pilha = Pilha()
pilha.empilhar("A")
pilha.empilhar("B")
pilha.empilhar("C")
pilha.empilhar("D")
pilha.empilhar("E")
print(pilha)
print(pilha.espiar())
from Mapa import Mapa
from Pilha import Pilha
mapa = Mapa()
'''mapa.getAdjascentesCidade(mapa.mafra)'''
pilha = Pilha(5)
print("----")
print(pilha.topo)
pilha.empilhar(mapa.curitiba)
pilha.empilhar(mapa.araucaria)
pilha.empilhar(mapa.irati)
pilha.getTopo().nome
from Pilha import Pilha
from random import randint
pilha = Pilha(10)
for i in range(10):
pilha.push(randint(0, 100))
print(pilha)
print(pilha.top)
pilha.pop()
print(pilha)
print(pilha.top)
print(pilha)
print(reversed(pilha))
def __init__(self, nome_do_campeonato):
self._nome_do_campeonato = nome_do_campeonato
self._surfistasP = Pilha()
self._surfistasF = Fila()
self._surfistasL = Lista()
from Pilha import Pilha
pilha = Pilha()
pilha.inserir("Rafael")
pilha.inserir("Lucas")
pilha.imprimir()
pilha.inserir("Sandra")
pilha.imprimir()
pilha.remover()
pilha.imprimir()
from Pilha import Pilha
pilha = Pilha()
print('Teste 1')
pilha.inserir(5)
pilha.inserir(10)
pilha.imprimir()
print('Teste 2')
pilha.inserir(3)
pilha.inserir(25)
pilha.imprimir()
print('Teste 3')
pilha.excluir()
pilha.imprimir()
print('Teste 4')
pilha.inserir(50)
pilha.inserir(100)
pilha.imprimir()
from Pilha import Pilha
pilha = Pilha()
pilha.adicionar(10)
pilha.adicionar(5)
pilha.adicionar(15)
pilha.adicionar(20)
valor = input("Digite um valor: ")
pilha.adicionar(valor)
resp = int(input("Deseja Excluir o item do topo? 1- Sim 2- Não: "))
if resp == 1:
pilha.excluir()
pilha.imprimir()
else:
print("Nada foi excluido. ")
pilha.imprimir()