INSTITUTO POLITECNICO

NACIONAL
Escuela Superior de Computo

COMPILADORES

PRACTICA 1- Programar un AFD

Profesora: ALBORTANTE MORATO CECILIA

Alumnos: Gutiérrez Espinosa Jordan Gabriel

Ricardo Bisogno Gandarilla

Grupo: 5CM2

Ciclo: 2022-2023(2)
 índice

Introducción----------------------------------------------------------------1

Desarrollo-------------------------------------------------------------------2
[AFD archivo].DAT----------------------------------------------------------------------------------2
Estado.java---------------------------------------------------------------------------------------------3
Automata.java-----------------------------------------------------------------------------------------4

Resultados-----------------------------------------------------------------11

Referencias----------------------------------------------------------------13
 INTRODUCCION

En la creación de un código con diferentes lenguajes de programación, se debe de seguir una

serie de reglas para que el lenguaje pueda comprender y convertir lo escrito en el código a
lenguaje maquina y así cualquier maquina (con las bases de hardware y software) lo pueda
ejecutar, por lo que en la compresión de los códigos usan en base los Autómata finitos
deterministas para que sigan las reglas del lenguaje para su compilación.
Un Autómata finito determinista según el M. en C. Edgardo Adrián Franco Martínez es “Un
autómata finito es un modelo matemático de una máquina que acepta cadenas de un lenguaje
definido sobre un alfabeto”, el alfabeto se refiere a una campo de caracteres que se van a
estar en la cadena y solo va a aceptar el modelo, El apartado de determinista se refiere a que
el modelo no presenta ninguna ambigüedad, lo cual se refiere a que en la inclusión de la
cadena los estados presentan un solo estado o estados en que se acepte la cadena y donde
debe terminar[1], Figura 1.

Figura 1, Ejemplo de Autómata Finito Determinista

En la creación de un AFD hay que tener en cuenta la condición que se quiera cumplir en la
cadena, después el Alfabeto que lo va a conformar y como este estará dividido, después en
los estados que lo conformara y las condiciones que lo van a conforma, después localizar la
lógica de ese autómata para cumplir la condición que impusimos, el autómata solo debe de
aceptar las cadenas que se cumplan con la condición del autómata, ya que la lógica sea
aceptable se revisa que las cadenas de pruebas sean aceptadas o rechazadas para comprobar
el funcionamientos del autómata[2].
En la inclusión de un AFD a un código de programación, hay que separar cada componente
del autómata para ingresarlo al lenguaje, Tendremos que ingresar la cantidad de símbolos
que conforman el alfabeto, y la cantidad de estados que lo conforman luego tendremos que

1
ingresar los símbolos del alfabeto para que se pasen cada uno de los estados, los estados los
genera solo no es necesario ingresarlo. Seguidamente tendremos que ingresar la matriz de
transición donde no olvidemos que remplazamos los nombres de los estados por número que
serían los índices [3].

DESARROLLO
En la Creación del código usamos el lenguaje de programación java, por su facilidad de
componentes y atajos en la composición para la facilidad de incluir cualquier autómata que
se incluya en el programa.
[AFD archivo].DAT
Primero hablemos de los archivos .dat que puede leer el programa, usaremos como ejemplo
el autómata de la Figura 2 y como están constituidos para la representación del autómata, en
la primera parte como se muestra en la Figura 3, se le da el nombre, El cual solo es para
reconocer el autómata y se colocará como texto en el programa main, no afecta de ninguna
manera al autómata, consecutivamente se da a entender los estados que este tendrá después
del “/”.

Figura 2, Autómata de ejemplo.

Figura 3, Reconocimiento de los Estados del AFD.

2
En la Figura 4, se muestra cómo va constituido los siguientes pasos en la construcción del
autómata, dándole un numero a cada estado, como también su condición para entrar después
del “/” y al final si se considera estado Final o de Transición entre estados (“F” =Estado de
transición, “T”=Estado final).

Figura 4, Nombramiento de estados del AFD.

Y en el ultimo apartado del documento del autómata como se muestra en la Figura 5, se da a

conocer primero el estado y después de cada “/” se da a conocer los diferentes estados al que
esté conectado.

Figura 5, Conexiones entre estados.

Estado.java
En esta clase de Java se va a revisar cada punto que nos interesa en él .DAT que sea lo que
contenga el autómata por cada estado que lo conforma, como también cambiar cualquier
carácter que contenga a variables Char con la función “charAt” para poder utilizar cualquier
carácter que contenga el alfabeto del automata y así que lo lea el programa, además de evitar
crear diferentes programas para diferentes tipos de AFD con caracteres diferentes. Como se
muestra en la Figura 6, en variables String, boolean y Char, para nombre, el estado y su
restricción.

Figura 6, Clase estados, nombramiento de las variables

En la Figura 7, se declara en el constructor Estado, la cual va a colocar en las variables de

estados, nombres, y restricciones que se hayan registrado del documento, así como también
convertir las “restricciones” a carteres Char para su comprobación más adelante, si el estado
no contiene ninguna restricción se le coloca un NULL.

3
 Figura 7, Función Estado.

En la Figura 8, se muestra cómo se va a colocar las diferentes variables de la clase con las
variables introducidas en la función estados, como también otra revisión a los caracteres de
restricciones para que sean tipo Char. Ya al final se da a conocer las variables que pida el
sistema con los public void “getName” y “getEstado” pero para las restricciones con la
función “getCompRestricciones” se va a dar a conocer si es un estado Final o de Transición
revisando el carácter que este sea introducido, regresando un False o un true para el
conocimiento del programa main.

Figura 8, Set y Get de las variables de Estados.

4
Automata.java
En el programa main como se muestra en la Figura 9, con el uso de la biblioteca “java.io.File”
y “java.io.FileReader” se va a declarar las variables que permiten la lectura de un archivo de
la computadora, dándole la dirección del archivo, para que el programe lo almacene y lo
pueda leer carácter por carácter, con este método podemos manejar que carácter se va a
colocar en las diferentes variables del programa y así manejarlas, como en la primera línea
en la cual con la ayuda de un if se va a llevar una condición mientras el primer carácter que
se lea sea “N” conlleve la lectura de cada carácter el cual será colocada en la variable
“nombreAutomata”, el contador se va a aumentar mientras el carácter leído no sea un “/” el
cual indica al programa que deje de leer hasta ese punto, después se da a conocer el nombre
del autómata que venia en el documento .DAT, al final de esta parte de va a cerra el
documento o se va a indicar que el documento no se pudo abrir.

Figura 9, Reconocimiento del archivo y nombre del AFD.

En el siguiente paso que mostrara el programa main, como se muestra en la Figura 10, se va
a abrir otra vez el archivo para que el programa le pida al usuario la palabra que dese que el
autómata revise y si los acepta, se le colocara en una variable para su revisión, dando a
conocer si la palabra colocada por el usuario fue aceptada o no por el programa con la función
“automataA” que se verá más abajo , se revisa si el archivo esta abierto, y al final se le
pregunta al usuario si quiere colocar otra palabra, si este coloca “S” se reinicia el while
colocado en este paso, si coloca “N” se sale del while y realiza la siguiente acción.

5
 Figura 10, palabra del usuario para el AFD.

En la Figura 11 se muestra mensajes de cerrado del archivo o de mensajes de error que da el

programa al usuario en la ejecución del programa.

Figura 11, Mensajes de cierre o error.

En la Figura 12, con el archivo aun abierto se va a leer el número de los estados haciendo
que el programa lea donde se quedó cada carácter hasta llegar a un “- “que es su indicador
que va a llegar a esa parte y después si no tiene “/” seguirá leyendo hasta llegar al carácter
“/” donde el programa leerá el siguiente carácter para colocarlo en un variable de
NumEstados que se utilizara para saber el conocimiento de número total de estados.

6
 Figura 12, Conocimiento del número de estados.

En la Figura 13, se integran nuevas variables que que serán el número de Estados “numE”
que está pasando lo que se escribió en el documento con valor char a un integer como un
arreglo que lo almacenara, la variable boolean “aceptado” que el programa utilizara para
saber si se aceptó la palabra, entonces el programa seguirá leyendo el archivo, con un ciclo
for utilizando como condición que la variable contadora no pase la variable numE, el
programa seguir leyendo con la condición que no se encuentre con un “-“ (que es el indicador
que la primera parte ya termino y debe seguir a las conexiones) que es el indicador del
documento que ahí termina los estados, va a leer el 1 carácter que es el indicador del estado,
con una condición de que si el carácter siguiente es un “/” va a colocar en otra variable su
condición de entrada, y al final se va a saber si es un estado final o de transición con el ultimo
carácter leído alado de “/” y se le dará un valor booleano de true si es “T” o false, para que
al final de leer la línea y antes de regresar a la siguiente colocar en un arreglo el estado para
después uso.

7
 Figura 13, guardados de los estados del autómata.

En la Figura 14, se muestra como se declara una variable arreglo con 2 dimensiones para
guardar las conexiones de los estados que esta en el archivo .DAT, para evitar la basura se
coloca en todos sus puntos usando la variable “numE” que es el conocimientos de los estados
que existe, se le coloca un 0, a continuación como el programa le avisamos que siguiera a
este paso después del carácter “-“ seguirá leyendo primero cada línea identificando su primer
carácter como su primero carácter el cual será el primer identificador del arreglo, ya cuando
el programa lea el siguiente carácter que contenga el archivo se va a revisar cuál es su
condición para que entre, esa condición será el segundo carácter en el arreglo, Por lo que el
arreglo quedaría como conexiones [estado][Condición del estado a que se quiere acceder], y
el numero 1 indicando que estos están conectados.

8
 Figura 14, Conexiones entre estados.

Ya por ultimo como se muestra en la Figura 15 con la cadena del usuario que presento, se va
a revisar cada uno de los estados colocando en el arreglo tomando y al principio como 0, si
en la combinación de y que es el estado y el carácter del usuario que es z, si en el carácter
que tiene el arreglo con esas 2 indicaciones da “1” y toma el número de z como y indicando
que el estado se ha cambiado y así continua hasta terminar la cadena, al final el programa da
a conocer por la variable boleana vinculada al estado que este y al terminar el ciclo, se da a
conocer si fue aceptada o no y se regresa al usuario para su conocimiento, terminando el
Código por si existe algún error en la ejecución del programa.

9
Figura 15, comprobación de la palabra en el AFD.

10
 Resultados
En la Figura 16 se comprueba como en la comparación este reconoce y coloca el nombre
del autómata que esta inscrita en él .dat

Figura 16, comparación entre el .dat y la ejecución del autómata.

En la Figura 17 se muestra como el programa pide la cadena que quiere poner el usuario, en
el caso de este grafo se acepta la palabra si es el numero binario par, por lo que en la 1 palabra
introducida se conoce por la regla que todo numero par binario termina en 0 por lo que la
palabra es aceptada.

Figura 17, palabra aceptada.

En la Figura 18 se muestra como el programa pregunta si quiere introducir otra palabra,

diciéndole que “S” reiniciando el proceso y pidiendo la palabra, por lo que en este caso se
introdujo una incorrecta colocándole un 1 al final sabiendo que sería impar, el programa salta
que la palabra fue rechazada, preguntando por ultima vez si quiere poner otra palabra,
colocándole “N” terminando el programa.

Figura 18, Palabra rechazada.

11
En la Figura 19 se muestra ahora otro AFD que solo acepta múltiplos de 8.

Figura 19, AFD múltiplos de 8.

Y por último en la Figura 20 se muestra el ultimo AFD que pide que en una cadena con 2 ceros
consecutivos mínimo dos 1.

Figura 20, AFD dos 1 con 2 ceros consecutivos.

12
 Referencias
[1]E. A. Franco Martínez, “Clase 09: AFN, AFD y Construcción de Thompson - PDF Free
Download,” docplayer.es. https://docplayer.es/21780698-Clase-09-afn-afd-y-construccion-
de-thompson.html (acceso Mar. 12, 2023).

[2]“CONSTRUCCIÓN DE AUTOMATAS FINITOS PASO A PASO,”

www.matesfacil.com. https://www.matesfacil.com/automatas-lenguajes/automatas-finitos-
lenguajes-regulares-ejercicios-resueltos.html (acceso Mar. 13, 2023).

[3]O. enlace, Facebook, Twitter, Pinterest, C. electrónico, and O. aplicaciones, “Autómata

Finito Determinista - Código C++.” https://blog.martincruz.me/2018/05/automata-finito-
determinista-codigo-c.html (acceso Mar. 13, 2023).

13