def result(self, state, action):
state_n = deepcopy(state)
index_position = [action[0], action[1], '#', action[3]]
state_n.positions[state.positions.index(index_position)] = action
estado = Estado(len(state_n.size), state_n.block_x, state_n.block_y,
state_n.positions)
return Estado(len(state_n.size), state_n.block_x, state_n.block_y,
state_n.positions)
def anadirEstado(self):
self.contadorEstados += 1
if self.inicial == 0:
self.estados.append(Estado(self.contadorEstados, True))
self.inicial = self.contadorEstados
else:
self.estados.append(Estado(self.contadorEstados, False))
return self.contadorEstados
def getEstados(linhas):
estados = {}
i = 3
while (i < len(linhas)):
linha = linhas[i].split(',')
if (linha[0] not in estados):
estados[linha[0]] = Estado(linha[0])
if (linha[2] not in estados):
estados[linha[2]] = Estado(linha[2])
i = i + 1
return estados
def descartar(self, nome, comando, param=None):
"""
Descarta os items do inventario.
:param nome: nome do usuario
:param param: lista de parametros carregadas do estado_salvo
:param comando: Nome do item a ser descartado ou nome do item a ser descartado mais
a quantia.
:return: Msg para o jogador. Salva no banco de dados.
"""
if param:
if comando == 'sim':
inv = json.dumps(param[0], ensure_ascii=False)
eqp = json.dumps(param[1], ensure_ascii=False)
self.orm.update_global(nome, inventario=inv, equipado=eqp)
Estado(self.orm).limpa_estado(nome)
return 'item excluido com sucesso!'
Estado(self.orm).limpa_estado(nome)
return 'excluir item cancelado'
try:
item, quantia = comando.split()
quantia = int(quantia)
if int(quantia) < 1:
return 'zero ou numeros negativos não são aceitos.'
except ValueError:
item = comando
quantia = 1
if item:
if self.orm.get_item(item).tipo == 'magia':
return 'voce nao pode descartar uma magia, o que se aprende nao se esquece...'
usr_glb = self.orm.get_global(nome)
bolsa = json.loads(usr_glb.inventario)
slots = json.loads(usr_glb.equipado)
if any([i[0] == item for i in bolsa]):
for k, v in enumerate(bolsa):
if v[0] == item:
if v[1] > quantia:
v[1] -= quantia
else:
bolsa.pop(k)
slots = {
key: '' if val == item else val
for key, val in slots.items()
}
err_msg = 'voçê estava descartando um item do seu inventario, para cancelar digite: DESCARTAR não'
Estado(self.orm).seta_estado(nome, 'DESCARTAR', [bolsa, slots],
err_msg)
return 'voçê tem certeza que quer excluir este item, se sim digite: "DESCARTAR sim".'
return 'esse item não existe no seu inventario. Escreva INVENTARIO para ver o que voce possui'
return 'voce nao escreveu qual item do inventario quer descartar.'
async def main():
capacidade, n = leitura_entradas()
estado = Estado(capacidade, n)
carro = ThreadCarro(capacidade, n, estado)
passageiras = [ThreadPassageiro(i + 1, estado) for i in range(n)]
await asyncio.gather(carro.rodar(),
*(passageira.rodar() for passageira in passageiras))
def from_file(file_name):
board_size = 0
player = Car("?")
exit_space = None
all = {}
with open(file_name, 'r') as f:
y = 0
for row in f.readlines():
x = 0
for col in row:
if col == "?":
if not player.begin:
player.set_begin(x, y)
else:
player.set_end(x, y)
all[col] = player
elif col == "S":
exit_space = Space(x, y,col)
elif col == " " or col == '\n':
x -= 1
elif col != "?" and col != "#" and col != "S":
car = Car(col)
if col not in all:
car.set_begin(x, y)
all[col] = car
else:
all[col].set_end(x, y)
x += 1
y += 1
return Estado(all, exit_space,6)
def bfs(estado_inicio):
global tamanio_maximo_frontera, nodo_objetivo, profundidad_maxima_busqueda
explorado, queue = set(), deque(
[Estado(estado_inicio, None, None, 0, 0, 0)])
while queue:
nodo = queue.popleft()
explorado.add(nodo.map)
if nodo.estado == estado_objetivo:
nodo_objetivo = nodo
return queue
vecinos = expandir(nodo)
for vecino in vecinos:
if vecino.map not in explorado:
queue.append(vecino)
explorado.add(vecino.map)
if vecino.profundidad > profundidad_maxima_busqueda:
profundidad_maxima_busqueda += 1
if len(queue) > tamanio_maximo_frontera:
tamanio_maximo_frontera = len(queue)
def main():
global CONT_ESTADO, AFND, ESTADOS, CONT_LINHA
# abre o arquivo em modo de leitura
arquivo = open('codOtimizado.txt', 'w')
arquivo.write(str(""))
arquivo.close()
with open("entrada.txt", "r") as arquivo:
for linha in arquivo:
if linha[len(linha) - 1] != '\n':
linha = linha + '\n'
if not AFND:
est = Estado()
est.rotulo = CONT_ESTADO
est.inicial = True
est.rotuloGr = 'S'
AFND.append(est)
CONT_ESTADO += 1
elif linha[0] == '<' and linha[1] != '=' and linha[1] != '\n':
le_gramatica(linha)
else:
le_token(linha)
determinizar()
mortos()
insere_estado_erro()
gerar_csv()
print_erros(lexic(), ERRO_LEX)
print_tabela_simbolos()
if not TABELA_ERROS:
aceita = analise_sintatica()
if aceita:
analise_semantica()
gera_codigo_intermediario()
otimizacao()
def _add_estado(self, rotulo):
estado = Estado()
estado.rotulo = self._count_estado
estado.rotuloGr = rotulo
self.estados.append(estado)
self._count_estado += 1
return estado
def gera_alunos(n):
ufcg_total = 0
uepb_total = 0
estado = Estado()
alunos = []
for i in range(n - 1):
aluno, universidade = cria_aluno(estado, i + 1)
if universidade == 'ufcg':
ufcg_total += 1
else:
uepb_total += 1
alunos.append(aluno)
if ufcg_total % 2 == 1: # Garantia de que número de cada universidade é par
ufcg_total += 1
alunos.append(ThreadAlunoUFCG(estado, n))
else:
uepb_total += 1
alunos.append(ThreadAlunoUEPB(estado, n))
print('\nForam gerados ' + str(n) + ' alunos: ' + str(ufcg_total) +
' da UFCG e ' + str(uepb_total) + ' da UEPB.\n')
return alunos
def terminal(estad, term):
global AFND, CONT_ESTADO, ALFABETO, ESTADOS
cont = 0
flag = 0
for i in ESTADOS:
if i.rotuloGr == estad:
break
cont += 1
for i in ESTADOS[cont].transicoes:
if i.rotulo == term:
flag = 1
i.transicoes.append(CONT_ESTADO)
if flag == 0:
transi = Transicao()
transi.rotulo = term
transi.transicoes.append(CONT_ESTADO)
ESTADOS[cont].transicoes.append(transi)
est = Estado()
est.final = True
est.rotulo = CONT_ESTADO
CONT_ESTADO += 1
ESTADOS.append(est)
AFND.append(est)
def main():
tabuleiroInicial = Tabuleiro()
pos_i = random.randint(0,2)
pos_c = random.randint(0,2)
tabuleiroInicial.board[pos_i][pos_c] = 'X'
estadoinicial = Estado(tabuleiroInicial, None, 0, 'Max')
estadoinicial.tabuleiro.imprimetabuleiro()
def nao_terminal(estad, term, nao_term):
global AFND, CONT_ESTADO, ALFABETO, ESTADOS
flag = 0
have_nao_term = False
cont = 0
rot = 0
for i in ESTADOS:
if i.rotuloGr == estad:
break
cont += 1
for i in ESTADOS:
if i.rotuloGr == nao_term:
have_nao_term = True
rot = i.rotulo
for i in ESTADOS[cont].transicoes:
if i.rotulo == term:
flag = 1
if have_nao_term:
if rot not in i.transicoes:
i.transicoes.append(rot)
else:
i.transicoes.append(CONT_ESTADO)
est = Estado()
est.rotulo = CONT_ESTADO
est.rotuloGr = nao_term
CONT_ESTADO += 1
ESTADOS.append(est)
AFND.append(est)
break
if flag == 0:
transi = Transicao()
transi.rotulo = term
if have_nao_term:
transi.transicoes.append(rot)
else:
transi.transicoes.append(CONT_ESTADO)
est = Estado()
est.rotulo = CONT_ESTADO
est.rotuloGr = nao_term
CONT_ESTADO += 1
ESTADOS.append(est)
AFND.append(est)
ESTADOS[cont].transicoes.append(transi)
def automatoSimples(simbolo, tag):
automato = Automato(tag) #Cria um novo automato
eInicial = Estado(True, False) #Cria um estado inicial
eFinal = Estado(False, True) #Cria um estado final
#Adiciona os estados no automato
automato.addEstado(eInicial)
automato.addEstado(eFinal)
automato.addEstadoInicial(eInicial)
automato.addEstadoFinal(eFinal)
transicao = Transicao(
eInicial, eFinal,
simbolo) #Cria uma transicao entre o estado final e inicial
eInicial.addTransicao(
transicao
) #Adiciona a transicao na lista de transicoes do estado inicial
automato.atualizaIds()
return automato
def expandir(nodo):
vecinos = list()
vecinos.append(
Estado(movimiento(nodo.estado, 1), nodo, 1, nodo.profundidad + 1,
nodo.costo + 1, 0))
vecinos.append(
Estado(movimiento(nodo.estado, 2), nodo, 2, nodo.profundidad + 1,
nodo.costo + 1, 0))
vecinos.append(
Estado(movimiento(nodo.estado, 3), nodo, 3, nodo.profundidad + 1,
nodo.costo + 1, 0))
vecinos.append(
Estado(movimiento(nodo.estado, 4), nodo, 4, nodo.profundidad + 1,
nodo.costo + 1, 0))
nodes = [vecino for vecino in vecinos if vecino.estado]
return nodes
def generaHijos(estado, posicionX, posicionY):
hijos = []
movimientos = [1, -1]
for i in movimientos:
_matriz = copy.deepcopy(estado.matrizNumeros)
i += posicionX
if (i >= 0 and i <= 2):
aux = _matriz[posicionY][i]
_matriz[posicionY][i] = 0
_matriz[posicionY][posicionX] = aux
hijos.append(Estado(_matriz))
for i in movimientos:
_matriz = copy.deepcopy(estado.matrizNumeros)
i += posicionY
if (i >= 0 and i <= 2):
aux = _matriz[i][posicionX]
_matriz[i][posicionX] = 0
_matriz[posicionY][posicionX] = aux
hijos.append(Estado(_matriz))
return hijos
async def main():
n = input('Quantos alunos virão ao bar hoje? (Default: n = 8) ')
try:
n = int(n)
except:
n = 8
estado = Estado()
alunos = [ThreadAluno(i + 1, estado) for i in range(n)]
await asyncio.gather(*(aluno.rodar() for aluno in alunos))
def uniaoOu(a1, a2, tag):
novoAutomato = Automato(tag) #Cria um novo automato
#Adicionando todos os estados dos automatos antigos no novo
estados1 = a1.getEstados()
estados2 = a2.getEstados()
for estado in estados1:
novoAutomato.addEstado(estado)
for estado in estados2:
novoAutomato.addEstado(estado)
#Criando novos estados
novoInicial = Estado(True, False)
novoFinal = Estado(False, True)
novoAutomato.addEstado(novoInicial)
novoAutomato.addEstado(novoFinal)
novoAutomato.addEstadoInicial(novoInicial)
novoAutomato.addEstadoFinal(novoFinal)
#Criando novas transicoes para os estados iniciais
iniciais1 = a1.getEstadosIniciais()
iniciais2 = a2.getEstadosIniciais()
for estado in iniciais1:
t = Transicao(novoInicial, estado, '')
novoInicial.addTransicao(t)
estado.setInicial(False)
for estado in iniciais2:
t = Transicao(novoInicial, estado, '')
novoInicial.addTransicao(t)
estado.setInicial(False)
#Criando novas transicoes para os estados finais
finais1 = a1.getEstadosFinais()
finais2 = a2.getEstadosFinais()
for estado in finais1:
t = Transicao(estado, novoFinal, '')
estado.addTransicao(t)
estado.setFinal(False)
for estado in finais2:
t = Transicao(estado, novoFinal, '')
estado.addTransicao(t)
estado.setFinal(False)
novoAutomato.atualizaIds()
return novoAutomato
def result(self, state, action):
state = deepcopy(state)
resultante = state
percept = state.percept(state.arrumador)
if action == "mover_baixo":
resultante = Estado(state.width,state.height,state.arrumador.mover_baixo(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "mover_cima":
resultante = Estado(state.width,state.height,state.arrumador.mover_cima(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "mover_esq":
resultante = Estado(state.width,state.height,state.arrumador.mover_esq(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "mover_direita":
resultante = Estado(state.width,state.height,state.arrumador.mover_direita(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "empurra_baixo":
percept = percept['baixo']
for caixa in state.local_caixas:
if caixa == percept[0]:
caixa.mover_baixo()
resultante = Estado(state.width,state.height,state.arrumador.mover_baixo(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "empurra_cima":
percept = percept['cima'][0]
for caixa in state.local_caixas:
if caixa == percept:
caixa.mover_cima()
resultante = Estado(state.width,state.height,state.arrumador.mover_cima(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "empurra_esq":
percept = percept['esq'][0]
for caixa in state.local_caixas:
if caixa == percept:
caixa.mover_esq()
resultante = Estado(state.width,state.height,state.arrumador.mover_esq(),\
state.local_alvos,state.local_caixas,state.local_paredes)
elif action == "empurra_direita":
percept = percept['direita'][0]
for caixa in state.local_caixas:
if caixa == percept:
caixa.mover_direita()
resultante = Estado(state.width,state.height,state.arrumador.mover_direita(),\
state.local_alvos,state.local_caixas,state.local_paredes)
self.nos_expandidos += 1
#print(resultante)
return resultante
def le_token(linha):
global AFND, ALFABETO, CONT_ESTADO
flag = 0
for i in AFND[0].transicoes:
if i.rotulo == linha[0]:
i.transicoes.append(CONT_ESTADO)
flag = 1
if flag == 0:
transic = Transicao()
transic.rotulo = linha[0]
transic.transicoes.append(CONT_ESTADO)
AFND[0].transicoes.append(transic)
if linha[0] not in ALFABETO and linha[0] != 'ε':
ALFABETO.append(linha[0])
i = 1
while linha[i] != '\n':
estad = Estado()
estad.rotulo = CONT_ESTADO
CONT_ESTADO += 1
trans = Transicao()
trans.rotulo = linha[i]
trans.transicoes.append(CONT_ESTADO)
estad.transicoes.append(trans)
AFND.append(estad)
if linha[i] not in ALFABETO and linha[0] != 'ε':
ALFABETO.append(linha[i])
i += 1
estad = Estado()
estad.rotulo = CONT_ESTADO
estad.final = True
estad.eh_token = True
CONT_ESTADO += 1
AFND.append(estad)
def generar_estados(self, casillas):
lista_estados = []
for i in casillas:
f, c = i.get_tupla()
valor = i.get_valor()
estado = Estado((f, c), valor)
estado.set_N(i.get_N())
estado.set_E(i.get_E())
estado.set_S(i.get_S())
estado.set_O(i.get_O())
listas_vecinos = self.generar_vecinos(estado)
estado.set_vecinos(listas_vecinos)
lista_estados.append(estado)
return lista_estados
def le_gramatica(linha):
global AFND, CONT_ESTADO, ALFABETO, I_LINHA, ESTADOS, CONT_GRAMM
I_LINHA = 1
std = split_nt(linha)
if std == 'S':
inicializa_estado()
CONT_GRAMM += 1
flag = 0
for i in ESTADOS:
if i.rotuloGr == std:
flag = 1
if flag == 0:
est = Estado()
est.rotulo = CONT_ESTADO
est.rotuloGr = std
CONT_ESTADO += 1
ESTADOS.append(est)
AFND.append(est)
while linha[I_LINHA] != '\n':
while linha[I_LINHA] == '>' or linha[I_LINHA] == ' ' or linha[I_LINHA] == ':' or linha[I_LINHA] == '=' or \
linha[I_LINHA] == '|':
I_LINHA += 1
if linha[I_LINHA] == '\n':
break
term = linha[I_LINHA]
if term not in ALFABETO and term != 'ε':
ALFABETO.append(term)
I_LINHA += 1
if linha[I_LINHA] == '<':
I_LINHA += 1
nao_term = split_nt(linha)
I_LINHA += 1
nao_terminal(std, term, nao_term)
else:
if term == 'ε':
for i in ESTADOS:
if i.rotuloGr == std:
i.final = True
if CONT_GRAMM > 1:
i.tipo = 1
else:
i.tipo = 0
terminal(std, term)
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 determinizar():
global AFND, AFD, CONT_ESTADO
CONTADOR = 0
fila = []
fila_aux = []
lista = []
lista.append(AFND[0].rotulo)
fila.append(lista)
fila_aux.append(lista)
while fila:
est = Estado()
est.rotulo = CONTADOR
CONTADOR += 1
for j in ALFABETO:
cont = 0
trans = Transicao()
trans.rotulo = j
for i in fila[0]:
if AFND[i].final:
est.final = True
if AFND[i].inicial:
est.inicial = True
if AFND[i].eh_token:
est.eh_token = True
if not AFND[i].eh_token:
if AFND[i].tipo == 0:
est.tipo = 0
else:
est.tipo = 1
for k in AFND[i].transicoes:
if k.rotulo == j:
for l in k.transicoes:
if l not in trans.transicoes:
trans.transicoes.append(l)
trans.transicoes.sort()
if trans.transicoes not in fila_aux:
if trans.transicoes:
fila.append(trans.transicoes)
fila_aux.append(trans.transicoes)
for c in fila_aux:
if c == trans.transicoes:
trans.trans = cont
cont += 1
est.transicoes.append(trans)
AFD.append(est)
fila.pop(0)
def __init__(self, arquivo):
self._count_estado = 0
self._count_gramatica = 0
self.estados = []
self.alfabeto = []
for linha in arquivo:
if linha[len(linha) - 1] != '\n':
linha = linha + '\n'
if not self.estados:
est = Estado()
est.rotulo = self._count_estado
est.inicial = True
est.rotuloGr = 'S'
self.estados.append(est)
self._count_estado += 1
elif linha[0] == '<' and linha[1] != '=' and linha[1] != '\n':
self._le_gramatica(linha)
def main():
pilaEstados = []
estadosVisitados = []
estadoFinal = None
ruta = []
#estadoInicial = Estado([[1,2,3],[4,5,6],[7,8,0]])
#estadoInicial = Estado([[1,2,3],[4,5,6],[0,7,8]])
#estadoInicial = Estado([[1,2,3],[0,5,6],[4,7,8]])
#estadoInicial = Estado([[4,0,7],[8,1,5],[6,3,2]])
estadoInicial = Estado([[5, 7, 2], [0, 6, 8], [1, 3, 4]])
pilaEstados.append(estadoInicial)
while (len(pilaEstados) > 0):
e1 = pilaEstados.pop()
pilaEstados, estadosVisitados, estadoFinal = busquedaEnProfundidad(
pilaEstados, estadosVisitados, e1)
if (estadoFinal != None):
generaRuta(estadoFinal, ruta)
hijos = len(ruta)
imprimeRuta(ruta)
print(hijos)
def insere_estado_erro():
global AFD
est = Estado()
est.rotulo = len(AFD)
est.rotuloGr = 'X'
est.final = True
AFD.append(est)
for _ in ALFABETO:
trans = Transicao()
trans.trans = est.rotulo
est.transicoes.append(trans)
for i in AFD:
for j in i.transicoes:
if j.trans == -1:
j.trans = est.rotulo
for i in AFD:
trans = Transicao()
trans.trans = est.rotulo
i.transicoes.append(trans)
def populateTransictions(self):
for state, transiction in self.__transictions.items():
newState = Estado(state, self.isEndState(state), self.__alphabet,
transiction)
self.states.append(newState)
def _adicionaEstado(self, indice, final): #Adiciona um estado a lista
self.estados.append(Estado(indice, final))
def createAutomato(self):
for estado, funcaoTransicao in self.__listaTransicoes.items():
newEstado = Estado(estado, self.__alfabeto, funcaoTransicao,
self.verificaSeEstadoFinal(estado))
self.__estados.append(newEstado)