Responda às questões abaixo: 1 a Questão: Indique todos casos de não determinismo do AFN acima

Transcrição

1 Exercícios 04 CENTRO UNIVERSITÁRIO DE BRASÍLIA - UniCEUB O Autômato Finito Não Determinístico (AFN) abaixo reconhece sentenças da linguagem L, definida sobre o alfabeto Σ = {0, 1, onde as sentenças: possuem um número múltiplo de 3 bits 0 e a primeira primitiva é um bit 1, ou possuem um número múltiplo de 4 bits 0 e a primeira primitiva é um bit 1 ou possuem um número múltiplo de 3 bits 1 e a primeira primitiva é um bit 0 ou possuem um número ímpar de bits 1 e a primeira primitiva é um bit 0.

2 Responda às questões abaixo: 1 a Questão: Indique todos casos de não determinismo do AFN acima Exemplo: o AF, estando no estado q0, ao processar a primitiva 0 pode assumir mais de um estado alternativo a saber: q10 ou q14. Ou seja: q0 x 0 q10 ou q0 x 0 q14 Cite os demais casos de forma semelhante ao acima exemplificado. 2 a Questão: Julgue em V (verdadeiro) ou F (falso) [ ] A linguagem L possui infinitas sentenças [ ] Se w = , então w L [ ] A linguagem L possui finitas sentenças [ ] Se w = , então w L [ ] Se w = 01011, então w L [ ] Se w = 1110, então w L [ ] Se w = 1011, então w L [ ] Se w = 0111, então w L [ ] Se w = , então w L [ ] Se w = 111 então w L [ ] Se w = , então w L [ ] Se w = , então w L [ ] Se w = , então w L [ ] Se w = , então w L 3 a Questão: Codifique no programa JFLAP o AFN acima. Após a codificação do AFN, teste no JFLAP as seguintes sentenças: (1) (2) Para testar no JFLAP, utilize a opção INPUT Step by State... clicando no botão Step. 3.1) a sentença w = pertence à linguagem L? Quantos caminhos o AFN montou após o processamento? Quais os estados após o término do processamento? 3.2) a sentença w = pertence à linguagem L? Quantos caminhos o AFN montou após o processamento? Quais os estados após o término do processamento?

3 4 a Questão: Mostre os caminhos que o AFN contrói para as sentenças (1) (2) ? Exemplo: Veja os caminhos iniciais que o AFN monta para as sentença w = Complete este processamento e faça para a outra sentença.

4 Implementação de AFN/AFD em linguagem de programação Uma maneira de se implementar um AFN/AFD pode ser utilizando-se basicamente três estruturas de dados simples: Estrutura 1: fita de entrada da sentença. Estrutura 2: Lista de transições do AF: uma estrutura de lista encadeada onde cada elemento da lista contém um objeto que por sua vez armazena o estado atual da máquina (estado do AF), a primitiva que está sendo lida na fita e o novo estado da máquina. Ou seja, esta lista encadeada nada mais é do que o grafo contendo as transições da máquina AF. Figura 1 Exemplo de AFN e estrutura para a Lista de transições do AFN

5 Estrutura 3: Lista de processamento do AF: uma estrutura de lista encadeada onde cada elemento da lista armazena um estado decorrente do processamento e um ponteiro para apontar para o estado que o originou (estado pai ). Esta estrutura é criada durante o processo de processamento da sentença que está armazenada na fita de entrada. Para entender a Lista de processamento do AF, considere o AFN acima e a sequência de processamento que o mesmo efetua para validar a sentença w = 11100, apresentada abaixo: Figura 2 Processamento do AFN para a sentença w = O processamento acima pelo AF será registrado na Lista de processamento do AF da seguinte forma: Figura 3 Lista de processamento do AFN para a sentença w = 11100

6 Codificação em JAVA Em ANEXO I, encontra-se um código em Java para processamento de AF (AFN ou AFD). Observe que no código apresentado no ANEXO I, as principais estruturas de dados estão implementadas na forma de variável do tipo ArrayList. //---> Principais Estruturas de Dados para o AFN e seu processamento ArrayList mtransicoesafn = new ArrayList(); ArrayList mestadosfinaisdoafn = new ArrayList(); ArrayList mcaminhos = new ArrayList(); Uma vantagem de uso do tipo ArrayList em Java deve-se ao fato de que este tipo de variável já implementa os ponteiros para os objetos anteriores e posteriores, pois o ArrayList é gerenciado como se fosse um vetor e, por isso, só precisamos referenciar algum elemento do vetor através de seu índice. Por exemplo, observe a Lista de processamento do AFN na Figura 3. No código em Java do ANEXO I, esta lista é o ArrayList mcaminhos. Para exemplificar, Em mcaminhos(0) encontra-se um objeto que tem o estado q0 e o índice de nó pai igual a 1. Em mcaminhos(8) encontra-se um objeto que tem o estado q1 e o índice de nó pai igual a 4. objeto armazenado na Lista de processamento foi implementado na classe denominada CNoProc (classe nó de processamento ) que tem o campo mestadoproc e o campo mindicenopai. //========================================================= // Classe para o objeto-elemento "Nó de processamanto" da lista mcaminhos //========================================================= class CNoProc { String mestadoproc; int mindicenopai; CNoProc() { public void fsetestadoproc(string avalor) { mestadoproc = avalor; public void fsetindicenopai(int avalor) { mindicenopai = avalor; public String fgetestadoproc() { return mestadoproc; public int fgetindicenopai() { return mindicenopai;

7 Para exemplificar (ver Figura 3), Em mcaminhos(0).mestadoproc o valor é q0 Em mcaminhos(0).mindicenopai o valor é 1 Em mcaminhos(8).mestadoproc o valor é q1 Em mcaminhos(8).mindicenopai o valor é 4 Em mcaminhos(1).mestadoproc o valor é q0 Em mcaminhos(1).mindicenopai o valor é 1 Para implementar as transições de estado do AFN (ver Figura 1), foi criado no código o ArrayList mtransicoesafn que deve conter objetos da classe CTransicao que tem o campo mestado (que é o estado em que máquina AF se encontra), o campo mprimitiva (que for lida na fita contendo a sentença processada) e o campo mnovoestado. //=================================== // Classe para o objeto Transição //=================================== class CTransicao { String mestado; String mprimitiva; String mnovoestado; CTransicao() { public void fsetestado(string avalor) { mestado = avalor; public void fsetprmitiva(string avalor) { mprimitiva = avalor; public void fsetnovoestado(string avalor) { mnovoestado = avalor; public String fgetestado() { return mestado; public String fgetprimitiva() { return mprimitiva; public String fgetnovoestado() { return mnovoestado;

8 Por exemplo, o seguinte trecho de código que se encontra na função fdefinirtransicoesdoafn() armazena as transições q0 x 0 q0 e q0 x 1 q0: //--- vtransicao = new CTransicao(); vtransicao.fsetestado("q0"); vtransicao.fsetprmitiva("0"); vtransicao.fsetnovoestado("q0"); mtransicoesafn.add(vtransicao); //--- vtransicao = new CTransicao(); vtransicao.fsetestado("q0"); vtransicao.fsetprmitiva("1"); vtransicao.fsetnovoestado("q0"); mtransicoesafn.add(vtransicao);

9 ANEXO I import java.awt.*; import java.awt.event.actionlistener; import java.awt.event.actionevent; import java.util.arraylist; public class AFN01a extends Frame implements ActionListener { int mlargura = 500; FlowLayout mfl = new FlowLayout(FlowLayout.CENTER); Panel mpainel1; Panel mpainel2; Panel mpainel3; Panel mpainel4; Panel mpainel5; Panel mpainel6; Panel mpainel7; Label mlbsentenca; TextField msentenca; Button mbtexecutar; TextArea mtxtexecucao; TextArea mtxtcaminhos; Label mlbsql; Button mbtfim; //---> Principais Estruturas de dados para o AFN e seu processamento ArrayList mtransicoesafn = new ArrayList(); ArrayList mestadosfinaisdoafn = new ArrayList(); ArrayList mcaminhos = new ArrayList(); //---> Construtor da Classe AFN01a... AFN01a() { super("afn - Processamento de AFN"); //------> Desenhar "lay-out" da tela... mpainel1 = new Panel(); mpainel2 = new Panel(); mpainel3 = new Panel(); mpainel4 = new Panel(); mpainel5 = new Panel(); mpainel6 = new Panel(); mpainel7 = new Panel(); mlbsentenca = new Label("Digite abaixo a senetença desejada");

10 msentenca = new TextField(50); mbtexecutar = new Button("Executar"); mtxtexecucao = new TextArea("Execução"); mtxtcaminhos = new TextArea("Caminhos ao final do processamento"); mlbsql = new Label(">>> A sentença é aceita ou não pelo AF? <<<"); mbtfim = new Button("Fim"); //------> Disposição dos painéis... mpainel1.setlocation(0,0); mpainel1.setbackground(new Color(255,128,128)); mpainel1.setsize(mlargura,50); mpainel1.add(mlbsentenca); add(mpainel1); // mpainel2.setlocation(0,50); mpainel2.setbackground(new Color(255,255,255)); mpainel2.setsize(mlargura,50); mpainel2.add(msentenca); add(mpainel2); // mpainel3.setlocation(0,100); mpainel3.setbackground(new Color(255,128,128)); mpainel3.setsize(mlargura,50); mpainel3.add(mbtexecutar); add(mpainel3); mbtexecutar.addactionlistener(this); // mpainel4.setlocation(0,150); mpainel4.setbackground(new Color(0,255,0)); mpainel4.setsize(mlargura,150); mpainel4.add(mtxtexecucao); add(mpainel4); // mpainel5.setlocation(0,350); mpainel5.setbackground(new Color(255,0,0)); mpainel5.setsize(mlargura,150); mpainel5.add(mtxtcaminhos); add(mpainel5); // mpainel6.setlocation(0,500); mpainel6.setbackground(new Color(255,128,128)); mpainel6.setsize(mlargura,50); mpainel6.add(mlbsql); add(mpainel5); // mpainel7.setlocation(0,550); mpainel7.setbackground(new Color(255,128,255));

11 mpainel7.setsize(mlargura,50); mpainel7.add(mbtfim); add(mpainel7); mbtfim.addactionlistener(this); //------> Mostar janela this.resize(mlargura,600); mfl.sethgap(100); this.setlayout(mfl); this.show(); //------> Definir os estado finais do AFN fdefinirestadosfinaisdoafn(); //------> Definir as transições do AFN ("desenhar" o grafo do autômato) fdefinirtransicoesdoafn(); //---> Implementação do AFN //===> Indicar aqui os estados finais do AFN... private void fdefinirestadosfinaisdoafn() { mestadosfinaisdoafn.add("q4"); //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ //---> ALUNO: complete aqui os estados finais do AF //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ //---> Implementação do AFN //===> Criar aqui o AFN propriamente dito... private void fdefinirtransicoesdoafn() { CTransicao vtransicao; vtransicao = new CTransicao(); vtransicao.fsetestado("q0"); vtransicao.fsetprmitiva("0"); vtransicao.fsetnovoestado("q10"); mtransicoesafn.add(vtransicao); //---

12 vtransicao = new CTransicao(); vtransicao.fsetestado("q0"); vtransicao.fsetprmitiva("0"); vtransicao.fsetnovoestado("q14"); mtransicoesafn.add(vtransicao); //--- vtransicao = new CTransicao(); vtransicao.fsetestado("q0"); vtransicao.fsetprmitiva("1"); vtransicao.fsetnovoestado("q1"); mtransicoesafn.add(vtransicao); //--- vtransicao = new CTransicao(); vtransicao.fsetestado("q0"); vtransicao.fsetprmitiva("1"); vtransicao.fsetnovoestado("q1"); mtransicoesafn.add(vtransicao); //--- //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ //---> ALUNO: complete aqui as transições do AF //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ //---> Processamento de Sentenca pelo AFN public void fprocessamentopeloafn() { String vfita = msentenca.gettext(); int vtamanhofita = vfita.length(); int icursor; String vprimitivalida; String Q; CNoProc vnoproc; int indnoatual; int indproximono; // é o nó que na lista será processado com a próxima primitiva lida... int indiniciodosresultados; // a partir deste nó, os estados são os estados dos // caminhos ao final do processamento das primitivas String vestadoproc; CTransicao vtransicao; int k; String vestado; String vprimitiva; String vnovoestado; String venter = String.valueOf((char)13) + String.valueOf((char)10); String vaux;

13 String vehqerro; mtxtexecucao.settext("inicio DO PROCESSAMENTO" + venter + "=========================" + venter); mcaminhos.clear(); // "limpar" para iniciar um novo processamento... //---> Estado inicial da máquina AFN Q = "q0"; vnoproc = new CNoProc(); vnoproc.fsetestadoproc(q); // estado atual de processamento vnoproc.fsetindicenopai(-1); // Nó-raiz não tem nó pai... mcaminhos.add(vnoproc); indnoatual = 0; // é o nó que atualmente está em processamento... indproximono = indnoatual + 1; // Próximo nó a ser processado com a próxima primitiva lida indiniciodosresultados = indnoatual; //---> loop para processar a fita... for (icursor = 0; icursor < vtamanhofita; icursor++) { vprimitivalida = vfita.substring(icursor,icursor+1); vaux = String.valueOf(iCursor+1); vaux = "Primitiva " + vaux + " = " + vprimitivalida; mtxtexecucao.append(" " + venter); mtxtexecucao.append(vaux + venter + venter); //------> Processamento de todos os estados disponíveis para a primitiva em questão... while (indnoatual < indproximono) { vnoproc = (CNoProc)mCaminhos.get(indNoAtual); vestadoproc = vnoproc.fgetestadoproc(); // é o estado atual de processamento... vaux = vestadoproc + " x " + vprimitivalida + " -> "; vehqerro = "S"; // em princípio supõe-se que não tem transição (ou seja, qe).. // > Avalia toda a lista de transições do AFN... for (k = 0; k < mtransicoesafn.size(); k++) { vtransicao = (CTransicao)mTransicoesAFN.get(k); vestado = vtransicao.fgetestado(); vprimitiva = vtransicao.fgetprimitiva(); if ( (vestadoproc.equalsignorecase(vestado)) && (vprimitivalida.equalsignorecase(vprimitiva)) ) { vnovoestado = vtransicao.fgetnovoestado(); vnoproc = new CNoProc(); vnoproc.fsetestadoproc(vnovoestado); vnoproc.fsetindicenopai(indnoatual); mcaminhos.add(vnoproc);

14 vaux += " " + vnovoestado + " ou "; vehqerro = "N"; // próxima transição da lista de transições do AFN if (vehqerro.equalsignorecase("n")) { vaux = vaux.substring(0,vaux.length()-4); else { vaux += " qe"; mtxtexecucao.append(vaux + venter); indnoatual++; // Próximo estado a ser avaliada com a primitiva lida indiniciodosresultados = indnoatual; indproximono = mcaminhos.size(); // próxima primitiva a ser lida... mtxtexecucao.append(venter + "====================" + venter + " FIM " + venter); //---> A variavel indiniciodosresultados marca os nós (até o final da lista mcaminhos) //---> que são os estados dos caminhos ao término da leitura da fita de entrada.. fmostrarcaminhos(indiniciodosresultados); //---> Mostrar os caminhos processados pelo AFN private void fmostrarcaminhos(int aindiniciodosestados) { String vfita = msentenca.gettext(); String venter = String.valueOf((char)13) + String.valueOf((char)10); mtxtcaminhos.settext("caminhos CONSTRUÍDOS PELO AFN" + venter + "=================================" + venter); //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ //---> ALUNO: implemente aqui a rotina de apresentação dos caminhos gerados pelo AF //\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/

15 //---> Verificar se é estado final private String fverificaseehestadofinal(string aestadoproc) { String vehestadofinal = "N"; int k; String vestadofinal; for(k = 0; k < mestadosfinaisdoafn.size(); k++) { vestadofinal = (String)mEstadosFinaisDoAFN.get(k); if (vestadofinal.equalsignorecase(aestadoproc)) { vehestadofinal = "S"; return vehestadofinal; // //---> Listener // public void actionperformed(actionevent e) { if (e.getactioncommand() == "Fim") { System.exit(0); if (e.getactioncommand() == "Executar") { fprocessamentopeloafn(); // //---> Programa principal // public static void main(string[] args) { new AFN01a();

16 //=================================== // Classe para o objeto Transição //=================================== class CTransicao { String mestado; String mprimitiva; String mnovoestado; CTransicao() { public void fsetestado(string avalor) { mestado = avalor; public void fsetprmitiva(string avalor) { mprimitiva = avalor; public void fsetnovoestado(string avalor) { mnovoestado = avalor; public String fgetestado() { return mestado; public String fgetprimitiva() { return mprimitiva; public String fgetnovoestado() { return mnovoestado; //======================================================================= // Classe para o objeto-elemento "Nó de processamento" da lista mcaminhos //======================================================================= class CNoProc { String mestadoproc; int mindicenopai; CNoProc() { public void fsetestadoproc(string avalor) { mestadoproc = avalor; public void fsetindicenopai(int avalor) { mindicenopai = avalor; public String fgetestadoproc() { return mestadoproc; public int fgetindicenopai() { return mindicenopai;

17 1 a Questão Codifique no JFLAP e codifique em linguagem Java (ou outra linguagem de sua preferência) um AFN para os seguintes problemas abaixo apresentados: Obs. 1: O código de programação DEVE receber como informação de entrada uma sentença e informar se a mesma pertence ou não à linguagem em questão. E todas as sequências de processamento do AFN devem ser impressas. Obs. 2: Você DEVE indicar onde ocorrem os não determinismos do AFN (1) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo cca ou cba, e possuam ao menos uma subpalavra (um substring) aaa ou bac e sufixo cba ou sufixo ca. (2) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo cca ou cba, e não possuam subpalavra (substring) aaa nem bac e possuam sufixo cba ou sufixo ca. (3) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo bcb ou bab, e possuam ao menos uma subpalavra (um substring) abc ou acc, e sufixo aaa ou sufixo ab. (4) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo bcb ou bab, e não possuam subpalavra (substring) abc nem acc, e possuam sufixo aaa ou sufixo ab.

18 (5) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo abc ou acc, e possuam ao menos uma subpalavra (um substring) bcb ou bab, e sufixo ccc ou sufixo cb. (6) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo abc ou acc, e não possuam subpalavra (substring) bcb nem bab, e possuasufixo ccc ou cb. (7) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo aaa ou bac, e possuam ao menos uma subpalavra (um substring) cca ou cbb, e sufixo cba ou sufixo ca. (8) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo aaa ou bac, e não possuam subpalavra (substring) cca nem cbb, e possuam sufixo cba ou sufixo ca. (9) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo cba ou aba, e possuam ao menos uma subpalavra (um substring) cab ou caa, e sufixo bbb ou sufixo ba. (10) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo bbb ou aba, e possuam ao menos uma subpalavra (um substring) cab ou caa, e sufixo acb ou sufixo bb. (11) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo bbb ou aba, e não possuam subpalavra (um substring) cab nem caa, e possuam sufixo acb ou sufixo bb. (12) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo aaa ou aac, e possuam ao menos uma subpalavra (um substring) aab ou aca, e sufixo cca ou sufixo cc.

19 (13) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo aaa ou aac, e não possuam subpalavra (um substring) aab nem aca, e possuam sufixo cca ou sufixo cc. (14) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo ccb ou cac, e possuam ao menos uma subpalavra (um substring) abc ou cba, e sufixo bbb ou sufixo bc. (15) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo ccb ou cac, e não possuam (substring) abc nem cba, e possuam sufixo bbb ou sufixo bc. (16) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo aca ou bca, e não possuam subpalavra (um substring) bba nem cbc, e possuam sufixo ccc ou sufixo ca. (17) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo aca ou bca, e possuam ao menos uma subpalavra (um substring) bba ou cbc, e sufixo ccc ou sufixo ca. (18) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo bcc ou acb, e possuam ao menos uma subpalavra (um substring) cba ou ccb, e sufixo aab ou sufixo ac. (19) Construa um Autômato Finito Não Determinístico (AFN) sobre o alfabeto Σ = {a, b, c, que reconheça a linguagem L onde as sentenças possuem prefixo bcc ou acb, e não possuam subpalavra (substring) cba nem ccb, e possuem sufixo aab ou sufixo ac. ** FIM ***