コード例 #1
0
 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)
コード例 #2
0
ファイル: afnd.py プロジェクト: IanMendozaJaimes/compiladores
    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
コード例 #3
0
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
コード例 #4
0
    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.'
コード例 #5
0
ファイル: main.py プロジェクト: JRobsonJr/concorrente
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))
コード例 #6
0
ファイル: game.py プロジェクト: BerNarDoMelow/cars
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)
コード例 #7
0
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)
コード例 #8
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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()
コード例 #9
0
ファイル: afnd.py プロジェクト: TADebastiani/COMPILADORES
 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
コード例 #10
0
ファイル: main.py プロジェクト: JRobsonJr/concorrente
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
コード例 #11
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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)
コード例 #12
0
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()
コード例 #13
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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)
コード例 #14
0
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
コード例 #15
0
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
コード例 #16
0
ファイル: main.py プロジェクト: ArmandoVn/proyectos_ia
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
コード例 #17
0
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))
コード例 #18
0
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
コード例 #19
0
ファイル: game.py プロジェクト: BerNarDoMelow/sokoban
    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
コード例 #20
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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)
コード例 #21
0
 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
コード例 #22
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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)
コード例 #23
0
ファイル: maquina.py プロジェクト: ogoes/Automato-de-Pilha
    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)
        ]
コード例 #24
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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)
コード例 #25
0
ファイル: afnd.py プロジェクト: TADebastiani/COMPILADORES
    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)
コード例 #26
0
ファイル: main.py プロジェクト: ArmandoVn/proyectos_ia
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)
コード例 #27
0
ファイル: main.py プロジェクト: TADebastiani/COMPILADORES
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)
コード例 #28
0
 def populateTransictions(self):
     for state, transiction in self.__transictions.items():
         newState = Estado(state, self.isEndState(state), self.__alphabet,
                           transiction)
         self.states.append(newState)
コード例 #29
0
 def _adicionaEstado(self, indice, final):  #Adiciona um estado a lista
     self.estados.append(Estado(indice, final))
コード例 #30
0
ファイル: automato.py プロジェクト: cristianomg/ProjetoDeLFA
 def createAutomato(self):
     for estado, funcaoTransicao in self.__listaTransicoes.items():
         newEstado = Estado(estado, self.__alfabeto, funcaoTransicao,
                            self.verificaSeEstadoFinal(estado))
         self.__estados.append(newEstado)