UNIVERSIDAD CATOLICA DE COLOMBIA

FACULTAD DE INGENIERÍA
INGENIERÍA DE SISTEMAS
FUNDAMENTOS DE CIENCIAS DE LA COMPUTACIÓN
Proyecto 1. Expresiones regulares y autómatas.

Introducción
Las expresiones regulares son una secuencia de caracteres y símbolos que definen un conjunto de cadenas o patrones,
normalmente representativos de otro grupo de caracteres, mayor, de tal forma que podemos comparar el patrón o la
cadena con otro conjunto de caracteres para ver las coincidencias. Las expresiones regulares están disponibles en casi
cualquier lenguaje de programación, pero aunque su sintaxis es relativamente uniforme, cada lenguaje usa su propio
dialecto. Las expresiones regulares son útiles para construir compiladores, validar entradas, construir procesadores de
texto entre otros. Este objeto es el que nos permite realizar operaciones sobre la secuencia de caracteres que queremos
validar o en la secuencia de caracteres en la que queremos buscar.

Objetivo
Diseñar autómatas finitos determinísticos que validen entradas a un sistema informático.

Problema
Implementar un programa que valide la entrada de los datos que digita un usuario cuando diligencia un formulario de
impuesto predial. El programa debe reconocer el patrón de los datos de entrada con autómatas de estado finito.

Interfaz del usuario

Requerimientos funcionales
Validar los siguientes 10 ítems de datos digitados por el usuario. Si el ítem cumple con las condiciones dadas a
continuación imprimir 1 de lo contrario imprimir 0.
1. Año gravable (un dos, un cero, dos dígitos. No puede ser mayor a 2018).
2. Chip (tres letras mayúsculas, un guión, cuatro dígitos, un guión, cuatro letras mayúsculas).
3. Matrícula inmobiliaria (tres dígitos, una letra mayúscula, ocho dígitos).
4. Cédula catastral (símbolo # –opcional–, uno a cuatro dígitos, una o más letras, cero o más dígitos).
5. Área del terreno (uno a seis dígitos, un punto, dos dígitos –no puede empezar por cero–).
6. Contribuyente (nombre y apellido o nombre y dos apellidos, o dos nombres y apellido o dos nombres y dos
apellidos –en todos los casos debe empezar con una sola letra mayúscula).
7. Documento de identificación (uno a diez dígitos –no puede empezar por cero–).
8. Dirección (cualquiera de la siguiente letras: C, K, T, D, A, de uno a tres dígitos, opcional una letra mayúscula,
símbolo #, de uno a tres dígitos, un guión, dos dígitos, opcional 25 letras mayúsculas o minúsculas o dígitos).
9. Correo electrónico (una o más letras minúsculas o dígitos, símbolo @, una o más letras minúsculas, un punto, tres
letras minúsculas, opcionalmente un punto seguido de dos letras minúsculas. –no puede empezar por www ni
htpp–).
10. Valor a pagar (de uno a doce dígitos, coma (,) como separador de números decimales comenzando en el lado
derecho de tres en tres).

Otros requerimientos
 Cada función debe leer una cadena s de tipo char.
 Cada función debe retornar cero si los datos son incorrectos o uno si los datos son correctos.
 Cada función debe tener las siguientes estructuras de datos: matriz de enteros (matriz de transición de estados)
delta, vector de enteros (estados) Q y vector de caracteres (símbolos de la cadena w).
 Organice el programa así:
/* ----------------------------------------------------------------------------
| Programa que valide la entrada de los datos que digita un usuario cuando |
| diligencia un formulario de Impuesto Predial. |
| El programa debe reconocer el patrón de los datos de entrada con automatas |
| de estado finito. |
| Asignatura: Autómatas y lenguajes. |
| Autor: |
| Codigo: Nombre: |
| Codigo: Nombre: |
| Codigo: Nombre: |
| Fecha: 28 de febrero de 2019 |
| Version: 1.0 |
| --------------------------------------------------------------------------*/

// Implementación de los autómatas (funciones)

// Expresión regular:
int AnioGravable( char cadena[] ) { }

// Expresión regular:
int Chip( char cadena[], ) { }

// Expresión regular:
int MatriculaInmobiliaria( char cadena[], ) { }

// Expresión regular:
int CedulaCatastral( char cadena[], ) { }

// Expresión regular:
int AreaTerreno( char cadena[], ) { }

// Expresión regular:
int Contribuyente( char cadena[], ) { }

// Expresión regular:
int DocumentoIdentificacion( char cadena[], ) { }

// Expresión regular:
int Direccion( char cadena[], ) { }

// Expresión regular:
int CorreoElectronico( char cadena[], ) { }

// Expresión regular:
int FechaDeclaracion( char cadena[], ) { }

// Programa principal
int main(int argc, char *argv[]) {

Evaluación
Cada autómata tiene valor de un punto.

Requisitos
1. Escribir el programa en C/C++.
2. Documentar el programa e identificarlo con los códigos y nombres de los tres integrantes del grupo.
3. Subir a AVA antes de las 11:55 del 28 de febrero de 2019.

Bibliografía
 De Castro Korgi, Rodrigo. Teoría de la Computación. Lenguajes, autómatas y gramáticas. Bogotá. Universidad
Nacional de Colombia.
 Kelley Dean. Teoría de autómatas y lenguajes formales. Madrid. Prentice Hall.