Proyecto 2do Parcial - Validador de RFC

Automata con pila

para validar RFC

Alumno: Huerta Valencia Rosendo Abdel

Lenguaje y Automatas II
Grupo: 5651
1
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

Contenido
APRENDIZAJE................................................................................................................................. 3
COMPETENCIAS............................................................................................................................. 3
OBJETIVO......................................................................................................................................... 3
INTRODUCCIÓN .............................................................................................................................. 4
¿Qué es un Autómata de Pila? ............................................................................................... 5
¿Cómo funciona? ....................................................................................................................... 5
Representación ........................................................................................................................... 5
DESARROLLO ................................................................................................................................. 6
Script de programa en C++ ...................................................................................................... 6
Capturas de ejecución de programa ..................................................................................... 9
Validación de AP en JFlap ..................................................................................................... 10
Traza de ejecución ................................................................................................................... 11
LINK DE VIDEO ............................................................................................................................. 12
CONCLUSIÓN ................................................................................................................................ 12
REFERENCIAS .............................................................................................................................. 12

2
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

APRENDIZAJE
• Detectar errores semánticos.
• Diseñar y seleccionar información sobre la construcción de un analizador semántico.
• Reconocer el manejo de tipos en las expresiones y el uso de operadores.
• Establecer las reglas para la conversión de tipos (casting) en expresiones.
• Agregar acciones semánticas a la estructura de la gramática.
• Manipular la tabla de conversión de símbolos y de errores y direcciones.
• Integrar equipos de trabajo para la construcción de un analizador semántico.

COMPETENCIAS
Específica(s):
Diseña mediante el uso de reglas semánticas dirigidas por sintaxis, un analizador semántico
para un compilador.

Genéricas:
• Capacidad de análisis y síntesis.
• Capacidad de organizar y planificar.
• Habilidad para buscar y analizar información proveniente de fuentes diversas.
• Solución de problemas.
• Toma de decisiones.
• Trabajo en equipo.
• Capacidad de aplicar los conocimientos.
• Habilidades de investigación.
• Capacidad de generar nuevas ideas.
• Liderazgo.
• Habilidad para trabajar en forma.
• Autónoma.
• Búsqueda del logro.

OBJETIVO
La creación de un autómata con pila aplicando conocimientos de diseño y lógica
para validar caracteres, con un ejemplo que se utiliza en sistemas como es el RFC.
Ya que la aplicación de autómatas puede ser de gran ayuda para filtrados,
validaciones de datos.

3
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

INTRODUCCIÓN

La pila funciona de que el último carácter

que se en ella es el primero en ("LIFO" por
siglas ingles), como empiláramos platos
uno de otro, el primero que hemos
colocado.
Un aspecto crucial de la pila es que sólo
podemos modificar su "tope", que es el
extremo por donde entran salen los
caracteres, Los caracteres de son antes
los que están encima de ellos.
La pila tendrá un alfabeto propio, que puede o no coincidir con el alfabeto de la
palabra de entrada Esto se justifica porque puede ser necesario introducir en la pila
caracteres especiales usados como separadores, según las necesidades de diseño
del autómata.
Al iniciar la operación de un AP, la pila se encuentra vacía. Durante la operación del
AP, pila puede ir recibiendo (y almacenando) caracteres, según lo indiquen las
transiciones ejecutadas. Al final de su operación, para aceptar una palabra, la pila
debe estar nuevamente vacía.
En los AP Ias transiciones de un estado a otro indican, además de los caracteres
que consumen de in entrada, también lo que se saca del tope de la pila, así como
también lo que se mete a la pila.
Antes de formalizar los AP, vamos a utilizar una notación gráfica, parecida a la de
los de los finitos, como en los AP (a) y (b).
Para las transiciones usaremos notación "omega/alfa/Beta", donde es (secuencia
de caracteres) que consume, lo que saca de la pila, que mete la pila
(W) Omega=entrada
(A) Alfa=lo que se saca
(B) Beta=lo que se mete

4
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

¿Qué es un Autómata de Pila?

Un autómata con pila, autómata a pila o autómata de pila es un modelo matemático
de un sistema que recibe una cadena constituida por símbolos de un alfabeto y
determina si esa cadena pertenece al lenguaje que el autómata reconoce.

¿Cómo funciona?
Los autómatas de pila, en forma similar a como se usan los autómatas finitos,
también se pueden utilizar para aceptar cadenas de un lenguaje definido sobre un
alfabeto A. Los autómatas de pila pueden aceptar lenguajes que no pueden aceptar
los autómatas finitos. Un autómata de pila cuenta con una cinta de entrada y un
mecanismo de control que puede encontrarse en uno de entre un número finito de
estados. Uno de estos estados se designa como estado inicial, y además algunos
estados se llaman de aceptación o finales.

Representación
Una máquina de este tipo se representa de la siguiente forma

Al igual que un autómata finito un autómata de pila cuenta con un flujo de entrada y
un flujo de control que puede encontrarse en uno de entre un número finito de
estados. Uno de estos estados se designa como el inicial y por lo menos un estado
es de aceptación.
La principal diferencia es que los autómatas de pila cuentan con una pila en donde
pueden almacenar información para recuperarla más tarde.

5
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

DESARROLLO
Script de programa en C++

#include <iostream>
#include<stack>

Stack:
La Libreria estándar de plantillas soporta el uso de estructuras de pila a
travez de la plantilla de clase stack, la cual posee el mecanismo de
operación necesario para manejar operaciones de insertar (push),
borrar(pop), entre otras. La clase stack posee únicamente cinco
métodos y dos constructores.

using namespace std;

stack <char> pila;

Declaramos en el método donde utilizamos la función para manejar

operaciones de insertar (push) o borrar(pop). Al igual condicionar que
se mueva como el AP en sus estados al ingresar las letras de nuestro
RFC. la lógica esta en que si la variables “estado” y la variable “símbolo“
es igual a los que se ingresa se retorne. Y continúa su camino hasta
llegar a su ultimo movimiento.

int mover(int estado, char simbolo){

if( estado == 0 && simbolo == 'H' )
{
pila.push('H');
return 0;
}
if( estado == 0 && simbolo == 'U' )
{
pila.push('U');
return 1;
}
if( estado == 1 && simbolo == 'V' )
{
pila.pop();
return 1;

6
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

}
if( estado == 1 && simbolo == 'R' )
{
pila.pop();
return 1;
}
if( estado == 2 && simbolo == '9' )
{
pila.pop();
return 1;
}
if( estado == 2 && simbolo == '5' )
{
pila.pop();
return 1;
}
if( estado == 3 && simbolo == '1' )
{
pila.push('1');
return 1;
}
if( estado == 3 && simbolo == '6' )
{
pila.pop();
return 1;
}
if( estado == 4 && simbolo == 'E' )
{
pila.push('E');
return 1;
}
if( estado == 4 && simbolo == '1' )
{
pila.pop();
return 1;
}
if( estado == 5 && simbolo == '9' )
{
pila.pop();
return 1;
}
return 0;
}

Declaramos una variable que lea los 12 caracteres ingresado en el

arreglo y se llame “palabra” así como otra variable llamada “i” que se
7
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

encarga de leer los estados del arreglo y al final variable “estado” que
es responsable de se recorra o lea todos los estados ingresados a la
pila o arreglo.

int scanner(char palabra[12] ){

int i = 0;
int estado = 0; //estado inicial

while(palabra[i])
{
estado = mover(estado,palabra[i]);
i++;
}

if ( estado == 0 && pila.empty()) //estado final

return 1;

return 0;
}

Por último mandamos a imprimir el resultado de la variable palabra par

que salga nuestro RFC leído, con una condición que si la variable
scanner es igual que la palabra es válido el RFC de lo contracción es
invalido.

int main(){
char palabra[12];

cout<<"\n\n\t\t****** V A L I D A D O R R F C ***** ";

cout<<"\n\n\t\tINGRESE RFC : ";
gets(palabra);

if( scanner(palabra))
cout<<"\n\n\t\t\t RFC VALIDO !!! ";

else
cout<<" \n\n\t\t\t RFC INVALIDO !!!!";

cout<<endl<<endl;

system("pause");
}

8
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

Capturas de ejecución de programa

9
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

Validación de AP en JFlap

10
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

Traza de ejecución
W = HUVR951116E19
Estado de pila Por leer Lo que está en pila
q0 HUVR951116E19 e
q1 UVR951116E19 H
q1 VR951116E19 U
q1 R951116E19 V
q2 951116E19 R
q2 51116E19 9
q3 1116E19 5
q2 116E19 1
q3 16E19 1
q3 6E19 1
q4 E19 6
q5 19 E
q5 9 1
q5 9 9
q5 e

11
Lenguajes y automatas II
 Proyecto 2do Parcial - Validador de RFC

LINK DE VIDEO
https://www.youtube.com/watch?v=IUnFUOpYns4

CONCLUSIÓN

Existe un tipo de autómata que define los lenguajes independientes del contexto.
Dicho autómata, conocido como “autómata de pila”, es una extensión del autómata
finito no determinista con transiciones, el cual constituye una forma de definir los
lenguajes regulares. El autómata de pila es fundamentalmente un AFN con la
adición de una pila. La pila se puede leer, se pueden introducir elementos en ella y
extraer sólo el elemento que está en la parte superior de la misma, exactamente
igual que la estructura de datos de una “pila”.

REFERENCIAS

A. Sanchis, A. Ledezma, J. Iglesias, B. García, J. Alonso, 6. Autómatas a pila,

Universidad Carlos III de Madrid.
Stackoverflow, ¿Cómo validar un RFC de México y su digito verificador?,
Diciembre de 2016
https://es.stackoverflow.com/questions/31713/cómo-validar-un-rfc-de-méxico-y-su-
digito-verificador

12
Lenguajes y automatas II