TECNOLOGICO DE ESTUDIOS SUPERIORES DE

VILLA GUERRERO

INGENIERIA EN SISTEMAS COMPUTACIONALES

MATERIA: LENGUAJES Y AUTOMATAS I

DOCENTE: ING. TOMAS MARTIN MANCO TORO

COMPENDIO DEL CURSO

INTEGRANTES:

MARIA CONCEPCION GARCIA GUADARRAMA

JOSE LUIS PEREZ PEDROZA
ALAN ARIZMENDI MIGUEL
TANIA EDITH VILCHIS VALLEJO

SEXTO SEMESTRE

GRUPO: 602
 INDICE
INTRODUCCION....................................................................................................................3
OBJETIVO.............................................................................................................................3
PRIMER PARCIAL ..................................................................................................................4
ALFABETO ........................................................................................................................4
CADENA ...........................................................................................................................4
LENGUAJE ........................................................................................................................5
ESTRUCTURA DE UN TRADUCTOR ......................................................................................6
FASES DE UN COMPILDOR.................................................................................................7
EXPRESION REGULAR ........................................................................................................9
DISEO DE EXPRESIONES REGULARES ................................................................................9
EJERCICIOS......................................................................................................................... 11
EJERCICIOS DE EXPRESIONES REGULARES ............................................................................ 15
PROYECTO EN FLEX AND BISON ........................................................................................... 19
SEGUNDO PARCIAL............................................................................................................. 21
CONCEPTOS ....................................................................................................................... 21
EJERCICIOS EN JFLAP ....................................................................................................... 24
PROYECTO...................................................................................................................... 27
TERCER PARCIAL................................................................................................................. 37
EJERCICIOS REALIZADOS EN CLASE ...................................................................................... 37
PROYECTO ......................................................................................................................... 44
CONCLUCIONES.................................................................................................................. 48
BIBLIOGRAFIA .................................................................................................................... 49
 INTRODUCCION

Este trabajo pretende representar todos los ejercicios y conceptos realizados

durante el curso de lenguajes y autmatas 1 desde los conceptos ms bsicos
de un lenguaje como lo son las cadenas y el alfabeto, as como su estructura,
para reconocer sus diferentes partes y el uso ya que en la actualidad se relaciona
con muchas reas del conocimiento.

OBJETIVO

Presentar los conceptos ms bsicos para el mejor entendimiento adems de

mostrar algunos ejercicios realizados durante la clase que facilitan ms el
entendimiento de los diferentes conceptos.
 PRIMER PARCIAL
ALFABETO
Un alfabeto es un conjunto finito no vaco de smbolos y se denota como .

La pertenencia de un smbolo a un alfabeto se denota como .

Ejemplo: Podemos representar el alfabeto de las letras minsculas que utiliza el
idioma espaol, el cual contiene los 27 smbolos siguientes:

y sabemos que la letra pertenece a este alfabeto, lo cual denotaremos

como .
Ya sabemos que los alfabetos son conjuntos, por lo que, todas las operaciones
de conjuntos se pueden aplicar a los alfabetos tambin.

Sean alfabetos, y ya que los alfabetos son conjuntos finitos, no

vacos, la unin de un nmero finito de ellos resulta en un conjunto no

vaco y finito, esto es, si y

La unin de un nmero arbitrario finito de alfabetos resultar en un conjunto finito

y no vaco, es ms, si y , son conjuntos no vacos,

entoces son conjuntos finitos, no vacos, y por lo

tanto sern considerados alfabetos vlidos.

CADENA
Una cadena o palabra es una secuencia finita de smbolos que pertenecen a un
alfabeto y comunmente se denota con la letra . La cadena vaca se denota
como y es una secuencia vaca de smbolos tomados de cualquier alfabeto
.
S el alfabeto es el espaol, algunas cadenas pueden ser
, y . Dada la definicin anterior, cualquier palabra que
contenga los smbolos del alfabeto es una cadena vlida, sin importar si esta
tiene o no significado alguno.

Si es cualquier cadena, su longitud se denota como , la longitud de una

cadena es el nmero de smbolos que contiene, por ejemplo, si tenemos la

cadena sobre el alfabeto espaol, . La cadena

vaca no tiene smbolos, por lo que

LENGUAJE
Un lenguaje es un conjunto de cadenas sobre un alfabeto definido, stas
pueden ser cualquier cadena , que cumpla con lo siguente, esta formada

por los smbolos donde .

El lenguaje vaco es aquel que no contiene cadenas y no es lo mismo que el

lenguaje formado por la cadena vaca , ste lenguaje se denota de la misma

manera que el conjunto vaco, .

S se tiene una cadena sobre un alfabeto y es el lenguaje compuesto

por algunas de las cadenas sobre el alfabeto y , entonces diremos

que es un miembro de .

Tipos de Lenguajes

Podemos encontrar varios tipos de Lenguajes:

Lenguaje Declarativos.- Son los ms parecidos al castellano o ingles en

su potencia expresiva y funcionalidad y estn ene le nivel ms alto
respecto a los otros. Son fundamentalmente lenguaje de rdenes,
denominados por sentencias que expresan Lo que hay que hacer en vez
de Como hacerlo

Lenguaje de Alto Nivel.- Son los mas utilizados como lenguaje de

programacin, Aunque no son fundamentalmente declarativos, estos
lenguajes permiten que los algoritmos se expresen en un nivel y estilo de
escritura fcilmente legible y comprensible por otros programadores.
Adems, los lenguajes de alto nivel suelen tener la caracterstica de
Transportabilidad.
 Lenguajes Ensamblador. Y Lenguaje Maquina.- Cada tipo de maquina
tiene su propio lenguajes de maquina distinto y su lenguaje ensamblador
asociado. El lenguaje ensamblador es simplemente una representacin
simblica del lenguaje maquina asociado, lo cual permite una
programacin menos tediosa que con el anterior.

ESTRUCTURA DE UN TRADUCTOR
Un traductor es un programa que tiene como entrada un texto escrito en un
lenguaje (lenguaje fuente) y como salida produce un texto escrito en un lenguaje
(lenguaje objeto) que preserva el significado de origen. Ejemplos de traductores
son los ensambladores y los compiladores.

En el proceso de traduccin se
identifican dos fases principales:

Fase de anlisis
 Fase de Sntesis

FASES DE UN COMPILDOR
Los compiladores son programas de computadora que traducen de un lenguaje
a otro. Un compilador toma como su entrada un programa escrito en lenguaje
fuente y produce un programa equivalente escrito en lenguaje objeto.
Un compilador se compone internamente de varias etapas, o fases, que
realizan operaciones lgicas. Es til pensar en estas fases como piezas
separadas dentro del compilador, y pueden en realidad escribirse como
operaciones codificadas separadamente aunque en la prctica a menudo se
integran.

Analizador lxico: lee la secuencia de caracteres de izquierda a derecha del

programa fuente y agrupa las secuencias de caracteres en unidades con
significado propio (componentes lxicos o tokens en ingles).

Las palabras clave, identificadores, operadores, constantes numricas, signos

de puntuacin como separadores de sentencias, llaves, parntesis, etc. , son
diversas clasificaciones de componentes lxicos.

Anlisis sintctico: determina si la secuencia de componentes lxicos sigue la

sintaxis del lenguaje y obtiene la estructura jerrquica del programa en forma de
rbol, donde los nodos son las construcciones de alto nivel del lenguaje.

Se determinan las relaciones estructurales entre los componentes lxicos, esto

es semejante a realizar el anlisis gramatical sobre una frase en lenguaje natural.
La estructura sintctica la definiremos mediante las gramticas independientes
del contexto.

Anlisis semntico: realiza las comprobaciones necesarias sobre el rbol

sintctico para determinar el correcto significado del programa.

Las tareas bsicas a realizar son: La verificacin e inferencia de tipos en

asignaciones y expresiones, la declaracin del tipo de variables y funciones
antes de su uso, el correcto uso de operadores, el mbito de las variables y la
correcta llamada a funciones.

Nos limitaremos al anlisis semntico esttico (en tiempo de compilacin),

donde es necesario hacer uso de la Tabla de smbolos, como estructura de datos
para almacenar informacin sobre los identificadores que van surgiendo a lo
largo del programa. El anlisis semntico suele agregar atributos (como tipos de
datos) a la estructura del rbol semntico.

Generacin y optimizacin de cdigo intermedio: la optimizacin consiste en la

calibracin del rbol sintctico donde ya no aparecen construcciones de alto
nivel. Generando un cdigo mejorado, ya no estructurado, ms fcil de traducir
directamente a cdigo ensamblador o mquina, compuesto de un cdigo de tres
direcciones (cada instruccin tiene un operador, y la direccin de dos
operndoos y un lugar donde guardar el resultado), tambin conocida como
cdigo intermedio.

Generacin de cdigo objeto: toma como entrada la representacin intermedia

y genera el cdigo objeto. La optimizacin depende de la mquina, es necesario
conocer el conjunto de instrucciones, la representacin de los datos (nmero de
bytes), modos de direccionamiento, nmero y propsito de registros, jerarqua
de memoria, encauzamientos, etc.

Suelen implementarse a mano, y son complejos porque la generacin de un

buen cdigo objeto requiere la consideracin de muchos casos particulares.

Tabla de Smbolos: es una estructura tipo diccionario con operaciones de

insercin, borrado y bsqueda, que almacena informacin sobre los smbolos
que van apareciendo a lo largo del programa como son: los identificadores
(variables y funciones) Etiquetas tipos definidos por el usuario (arreglos,
registros, etc.)

Adems almacena el tipo de dato, mtodo de paso de parmetros, tipo de

retorno y de argumentos de una funcin, el mbito de referencia de
identificadores y la direccin de memoria. Interacciona tanto con el analizador
lxico, sintctico y semntico que introducen informacin conforme se procesa
la entrada. La fase de generacin de cdigo y optimizacin tambin la usan.

Gestor de errores: detecta e informa de errores que se produzcan durante la

fase de anlisis. Debe generar mensajes significativos y reanudar la traduccin.

Encuentra errores: En tiempo de compilacin: errores lxicos (ortogrficos),

sintcticos (construcciones incorrectas) y semnticos (p.ej. errores de tipo) En
tiempo de ejecucin: direccionamiento de vectores fuera de rango, divisiones por
cero, etc. De especificacin/diseo: compilan correctamente pero no realizan
lo que el programador desea.
Se trataran slo errores estticos (en tiempo de compilacin). Respecto a los
errores en tiempo de ejecucin, es necesario que el traductor genere cdigo para
la comprobacin de errores especficos, su adecuado tratamiento y los
mecanismos de tratamiento de excepciones para que el programa se contine
ejecutando.

La mayora de los compiladores son dirigidos por la sintaxis, es decir, el proceso

de traduccin es dirigido por el analizador sintctico. El anlisis sintctico genera
la estructura del programa fuente a travs de tokens. El anlisis semntico
proporciona el significado del programa basndose de la estructura del rbol de
anlisis sintctico.

EXPRESION REGULAR
Una expresin regular se construye a partir de expresiones regulares ms
simples utilizando un conjunto de reglas definitorias. Cada expresin regular r
representa un lenguaje L(r). Las reglas de definicin especifican cmo se forma
L(r) combinando de varias maneras los lenguajes representados por las
subexpresiones de r.

DISEO DE EXPRESIONES REGULARES

Las siguientes son las reglas que definen las expresiones regulares del alfabeto
. Asociada a cada regla hay una especificacin del lenguaje representado por
la expresin regular que se est definiendo.

1. es una expresin regular designada por {}; es decir, el conjunto que

contiene la cadena vaca.
2. Si a es un smbolo de , entonces a es una expresin regular designada
por {a}; por ejemplo, el conjunto que contiene la cadena a. Aunque se usa la
misma notacin para las tres, tcnicamente, la expresin regular a es distinta de
la cadena a o del smbolo a. El contexto aclarar si se habla de a como expresin
regular, cadena o smbolo.

3. Suponiendo que r y s sean expresiones regulares representadas por los

lenguajes L(r) y L(s), entonces,

1. (r) 1 (s) es una expresin regular representada por L(r) U L(s).

2. (r)(s) es una expresin regular representada por L(r)L(s).

3. (r)* es una expresin regular representada por (L(r))*.

4. (r) es una expresin regular representada por L(r)2.

Se dice que un lenguaje designado por una expresin regular es un conjunto

regular. La especificacin de una expresin regular es un ejemplo de definicin
recursiva. Las reglas 1 y 2 son la base de la definicin; se usa el trmino smbolo
bsico para referirse a o a un smbolo de que aparezcan en una expresin
regular. La regla 3 proporciona el paso inductivo.

Se pueden evitar los parntesis innecesarios en las expresiones regulares si se

adoptan las convenciones:

1. El operador unario * tiene la mayor precedencia y es asociativo por la

izquierda,

2. La concatenacin tiene la segunda mayor precedencia y es asociativa por

la izquierda,

3. | tiene la menor precedencia y es asociativo por la izquierda.

Segn estas convenciones, (a)| ((b)*(c)) es equivalente a a|b*c. Estas dos

expresiones designan el conjunto de cadenas que tienen una sola a, o cero o
ms b seguidas de una c.
 EJERCICIOS
ALFABETO
TRANSICIONES
EJERCICIOS DE EXPRESIONES REGULARES
 PROYECTO EN FLEX AND BISON
EJERCICIO 1

REALIZAR SUMA DE DOS NUMEROS.

EJERCICIO 2

DETECTAR LA PALABRA MAS LARGA Y CONTAR LOS CARACTERES

EJERCICIO 3

OPERACIONES BSICAS.

EJERCICIO 4

DETECTAR IDENTIFICADORES, NUMEROS Y OPERADORES

EJERCICIO 5

REMPLAZAR LETRAS

SEGUNDO PARCIAL

CONCEPTOS
Durante este parcial hicimos uso de Jflap para realizar un conjunto de ejercicios
de expresiones regulares.

JFLAP es un software para experimentar con temas de lenguajes formales

incluyendo autmatas finitos no determinsticos, autmatas pushdown no
determinsticos, mquinas Turing de mltiples cintas, varios tipos de gramticas,
anlisis y sistemas L. Adems de construir y probar ejemplos de estos, JFLAP
permite experimentar con pruebas de construccin de una forma a otra, como
convertir un NFA a un DFA a un estado mnimo DFA a una expresin regular o
gramtica regular.
 EJERCICIOS EN JFLAP
Terminacin 01

Terminacin 10
Terminacin 11

Cadena de nombre
Impares

Expresin regular
 PROYECTO
1: AUTOMATAS FINITOS
Este ejemplo reconocer toda cadena que tenga un impar de unos.
Comenzamos eligiendo la siguiente opcin

Tenemos que dar una transicin del estado inicial al final.

ESTADO INICIAL ESTADO FINAL

TRANSACCION
De esta manera se crea otra transaccin de q1 a q0 que es de no aceptacin
con esto se tiene el primer ciclo en el cundo se lea el primer uno se pase a
estado final y luego el segundo uno ase la cantidad par y se pasa a estado inicial
el siguiente uno se vuelve a regresar a estado final y da tres .

Ahora damos clic en imput, luego elegimos Multiple Run para poder checar el
resultado de nmeros impares.
Ahora colocaremos unos ejemplos para checar que funciona correctamente

El autmata funciono correctamente aceptando nicamente los nmeros

impares.

2: EXPRESIONES REGULARES

Como primer caso contamos con una expresin regular

Ahora para ver que la expresin regular funcione damos clic en las siguientes
opciones.

Para continuar colocamos una cadena que ser aceptada y veremos cmo
funciona.

cadena
Como se muestra comienza con a y es marcado q0, ahora daremos clic en Step
para que contine en el siguiente estado as continuara si es aceptada la cadena

En la siguiente imagen nos muestra que la cadena no es aceptada por que no

cuenta con la transicin D
Si corregimos y colocamos la transaccin faltante debe aceptar la expresin
regular.

3: Conversin AFND a AFD

Convertiremos el siguiente autmata finito no determinstico (una de sus
caractersticas es que posee transacciones vacas) en su equivalente autmata
finito determinstico.
Ahora iremos a las siguientes opciones

Y nos aparecer de la siguiente forma para continuar damos clic en Done, le

damos clic en aceptar para abrir la siguiente ventana
Obtendremos otra venta nueva

Ahora continuamos con los siguientes pasos

Se obtendr la siguiente forma

Ahora damos clic en la siguiente opcin

Y tendremos la siguiente forma

Para continuar le daremos finalizar y nos mostrara otra ventana

ahora le daremos clic en complete para continuar

Como siguiente paso da clic en Done y damos clic en aceptar

 TERCER PARCIAL

EJERCICIOS REALIZADOS EN CLASE

EJERCICIO 1

A partir de texto ya ingresado se aplicar un salto de lnea.

Cdigo en ejecucin.
EJERCICIO 2

Uso de cadenas, el usuario ingresara su nombre, apellido y edad y se agregara

un salto de lnea en cada dato.

Programa en ejecucin.
EJERCICIO 3

Separadores, a partir de ciertas palabras una vez ejecutadas se dar un salto de

lnea.

Cdigo en ejecucin.
EJERCICIO 4

Creacin de una base de datos de una farmacia

Programa en ejecucin.
Ejercicio 5

Integrantes del grupo 602

Programa en ejecucin.
Ejercicio 6

Base de datos de artculos.

Programa en ejecucin.
Ejercicio 7

Sustituir colores

Programa en ejecucin.
 PROYECTO
ANALIZADOR.

PASOS

1. Abrir Jflat

2. Elegimos autmata finito (Finite automaton)

3. Agregamos el estado inicial, el esta
4--Elaboramos la estructura
5.-Elegimos imput, despus multirun

6.-Agregamos las variables a evaluar

7.-Elegimos run imputs

Analizador para operadores aritmticos, palabras reservadas y literales

1. Abrimos visual studio
2. Elegimos nuevo proyecto
3. El proyecto deber ser c# de consola
4. Pedimos la palabra con el siguiente codido:
Console.WriteLine("Escriba una palabra");
cadena = Console.ReadLine();
5. Con el siguiente cdigo vamos a evaluar la cadena escrita

6. Agregamos para cada control y para las palabras

7. Agregamos aparte otro modulo para los operadores aritmticos

8. Corremos la aplicacion
 9. Escribimos unas palabras

10. Presionamos enter y nos aparecer que son palabras reservadas, que son operadores
aritmticos y que son literales

CONCLUCIONES
Mediante el uso de diferentes herramientas como lo son flex and bison, visual
studio, jflap creamos diferentes ejercicios que nos ayudaron a reforzar ms
nuestros conocimientos sobre la teora de autmatas.
 BIBLIOGRAFIA
http://ocw.uc3m.es/ingenieria-informatica/teoria-de-automatas-y-lenguajes-
formales/ejercicios/ejercicios-tema-3-automatas-finitos

http://ocw.uc3m.es/ingenieria-informatica/teoria-de-automatas-y-lenguajes-
formales/ejercicios/ejercicios-tema-6-automatas-a-pila

http://ocw.uc3m.es/ingenieria-informatica/teoria-de-automatas-y-lenguajes-
formales/ejercicios/ejercicios-tema-5-lenguajes-regulares/view