Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Tema1 PDF
Tema1 PDF
enfoque práctico
15 de abril de 2012
2
Índice general
1. Introducción 5
1.1. Marco histórico de la teoría de la computación . . . . . . . . . . . . . . . . . . 5
1.2. Conceptos básicos: Alfabeto, Palabra o Cadena, Lenguaje y Problema . . . . . 7
1.3. Jerarquía de Chomsky . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4. Los problemas en la Teoría de la Computación . . . . . . . . . . . . . . . . . . 10
1.5. Preguntas y respuestas, ejercicios resueltos y propuestos . . . . . . . . . . . . . 11
2. Lenguajes Regulares y autómatas nitos 15
2.1. Autómatas de estados nitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.1. Autómatas nitos determinista (AFD) . . . . . . . . . . . . . . . . . . . 15
2.1.2. Autómatas nitos no determinista (AFND) . . . . . . . . . . . . . . . . 19
2.1.3. Autómatas nitos no determinista con transiciones nulas (AFND-λ) . . 23
2.1.4. Herramientas, implementación y uso de Lenguajes regulares . . . . . . . 29
2.1.5. Preguntas y respuestas, ejercicios resueltos y propuestos . . . . . . . . . 32
3
4 ÍNDICE GENERAL
Capítulo 1
Introducción
La teoría de la Computación es un poco más antigua que las computadoras electrónicas.
Uno de sus pioneros, Alan Turing, pudo anticipar el poder de las computadoras a través de
un modelo conceptual en 1936. Otras disciplinas como la matemática, losofía, lingüística,
biología e ingeniería eléctrica intervienen para completar sus teorías. Las teorías de bases son
dos: Teoría de Autómatas y Teoría de los Lenguajes Formales. En general, la Teoría de la
Computación facilita la comprensión de muchas áreas de la ciencia de la computación (como
los compiladores), además:
1. Se utiliza en el diseño y construcción de aplicaciones importantes de software y hardware.
2. Ayuda a comprender que esperar del software.
3. Permite deducir si es posible resolver un problema (determinar los límites de la compu-
tación).
Además, la comprensión de estas teorías representa en la práctica un conjunto de herramientas
muy útiles como alternativas simples y ecientes para resolver problemas.
5
6 CAPÍTULO 1. INTRODUCCIÓN
En 1930, el matemático checo Kurt Gödel prueba que las matemáticas no pueden ser
completas y consistentes al mismo tiempo (teorema de la Incompletitud).
En ese mismo año 1936, el matemático inglés Alan Turing da una respuesta también
negativa a esa tercera cuestión, sus resultados son más consistentes que los obtenidos
por Church. La demostración de Turing se basa en principios completamente básicos
y elementales. Turing enuncia el problema de decisión de la siguiente forma: "Buscar
un algoritmo para determinar si una conclusión particular puede derivarse de ciertas
premisas con el uso de reglas de prueba". Da una noción precisa del concepto de algoritmo,
como aquello que pueda ser realizado por una máquina abstracta, la Máquina de Turing.
De este modo, Alan Turing con su máquina universal capaz de realizar el trabajo de
cualquier otra máquina, mediante la lectura de su descripción en una cinta, delinea el
diseño de un computardor.
En 1969, S. Cook extiende el estudio de Tuning. Cook separa aquellos problemas que
pueden ser solucionados de aquellos que en principio pueden ser solucionados pero que
en la práctica toman demasiados recursos (Complejidad computacional).
En 1956, Moore publica el primer estudio riguroso sobre autómatas. Con anterioridad,
debido al desarrollo de los primeros computadores, se habían estudiado diversos métodos
para la síntesis de circuitos secuenciales (Human en 1954 y Mealy en 1955). En los años
60 es donde se realizan la mayor parte de trabajos sobre la teoría de los autómatas nitos.
Ejemplo:
Dados los conjuntos A = {1,2} y B = {2,3}, se realizan las siguientes operaciones sobre
conjuntos:
∪
A B = {1, 2, 3}
∩
A B = {2}
A - B = {1}
A × B = {(1,2),(1,3),(2,2),(2,3)}
2A = A∗ = {ϕ,{1},{2},{1,2}}
1
Nota: ϵ es un símbolo que puede ser utilizado por algunos autores para denotar a la cadena vacía.
8 CAPÍTULO 1. INTRODUCCIÓN
el Σ+ = Σ∗ − {λ}
e ) Sujo, Prejo: cualquier cadena al nal o comienzo respectivamente de la cadena.
Por ejemplo para la cadena w=abca, formada de Σ = {a, b, c}, se tiene:
Los prejos de w= λ, a, ab, abc, abca
Los sujos de w= λ, a, ca, bca, abca
f ) Prejo (Sujo) propio, es cualquier Prejo (Sujo) que no sea la misma cadena.
3. Lenguaje: Conjunto de cadenas de símbolos del mismo alfabeto. El lenguaje formado
por toda las cadenas posibles de un alfabeto se denota por Σ∗ (Sigma asterisco).
ϕ es el lenguaje vacío, es un lenguaje para cualquier alfabeto.
{λ} es un lenguaje formado por la cadena vacía. Es un lenguaje para cualquier
alfabeto Σ.
Por Ejemplo: Σ1 = {0, 1}, Σ2 = {00, 1} 2
Σ∗1 = {λ, 0, 1, 00, 01, 10, 11, 000, 001, 010, 011, 100, ... }
Σ∗2 = {λ, 00, 1, 001, 100, 0000, 11, 00001, 00100, 10000, 1001, 0011, 111, 000000,...
}
Las cadenas formadas con Σ2 al aplicarle la cardinalidad: |001| = 2 y |1100| = 3
1.3. JERARQUÍA DE CHOMSKY 9
2
Los símbolos del alfabeto pueden ser de diferentes tamaños
10 CAPÍTULO 1. INTRODUCCIÓN
decisión que motivó a Turing y a Church a dar origen a la Teoría de la Computación en 1936.
Un ejemplo típico de este tipo de problema es la siguiente pregunta: ¾Es primo un número
entero dado?, y una instancia de este problema sería: ¾Es 17 un número primo?. Se trata de
entender al 17 como un elemento del conjunto de todos los números enteros y se quiere saber
si pertenece al conjunto de los números primos.
Lo anterior lleva a la pregunta de si realmente es posible reducir o redenir todos los problemas
a la forma de un problema de decisión. Para lo cual le sugiero platearse ejemplos e investigar
esta posibilidad, pues es en base a esta generalización de problemas sobre la cual funciona la
Teoría de la Computación. Esto puede parecer una desventaja, como lo menciona Hopcroft [2]:
poderosa en la medida que soluciona problemas sin importar como lo hace (no importa
la eciencia en tiempo y recursos, sino su efectividad en lograr resolver el problema). En
los términos del paradigma, si una máquina reconce lenguajes más complejos será más
podedora, según la Jerarquía de Chomsky la máquina que reconoce el lenguaje tipo 0 es
la más poderosa.
Ejercicios resueltos
1. Diferencia entre el operador clausura de Kleene aplicado sobre un conjunto y sobre un
alfabeto. Por ejemplo: El conjunto A = {a,b} cuál es el A* y para el alfabeto B = {a,b}
cuál es B*.
La diferencia se debe a que el operador estrella o clausura de Kleene es polimórco.
Aunque A y B son el mismo conjunto, se interpretan de forma diferente para el operador.
En el caso de A es un conjunto de elementos y A* es el conjunto de todos sus subconjuntos,
A es nito y A* también, A* = {ϕ, {a}, {b}, {a, b}}. En el caso de B, es interpretado
como un alfabeto, es decir un conjunto nito de símbolos. Aplicando el mismo operador
a B nos dá un conjunto innito, B* = {λ, a, b, aa, ab, ba, bb, aaa, aab, aba, ... } (se
está formando el conjunto de todas las cadenas, incluyendo la cadena vacía, que se puede
formar con el alfabeto B).
2. Considere el proceso de compilación de un programa escrito en un lenguaje de pro-
gramación. Identique el alfabeto, cadena, lenguaje y problema según la Teoría de la
Computación.
El problema de la compilación de un programa escrito en algún lenguaje de programación
puede ser visto a través del paradigam de lenguajes formales que contiene la Teoría de
la Computación. El compilador no es más que un sistema que es capaz de ver si una en-
trada (el código fuente) esta bien escrito y sigue las reglas del lenguaje de programación
que está reconociendo. Es decir, el compilador es una máquina reconocedora de textos
(códigos fuente) que pertenecen al conjunto de todos los códigos escritos en un lenguaje
de programación. De esta forma se denen:
El alfabeto Σ: es el conjunto de símbolos que puede escribirse en un teclado de
computador con el cual puede escribirse texto (caracteres alfanuméricos, caracteres
especiales, espacio, etc.).
Cadena de entrada w: La entrada del compilador visto como una máquina reco-
nocedora, no es más que cualquier texto que podamos escribir con el teclado del
computador (es decir con Σ). Cada cadena w se puede generar concatenando ele-
mentos de Σ, de esta maneras tenemos innitas cadenas (textos)y entonces Σ∗ es
innito.
El lenguaje L: es el subconjunto de Σ∗ formado por las cadenas (texto) que siguen
las reglas de un lenguaje de programación especíco. El compilador reconoce un
lenguaje L innito pues las reglas de un lenguaje de programación (aunque son
nitas) permiten escribir innitos programas que formarían parte de L.
El problema P: El compilador resuelve un problema de decisión al determinar si un
texto de entrada compila o no. Decir que un texto compila signica que pertenece
al lenguaje L de todas los posibles e innitos códigos que pueden escribirse en
1.5. PREGUNTAS Y RESPUESTAS, EJERCICIOS RESUELTOS Y PROPUESTOS 13
Ejercicios propuestos
1. ¾Qué es un lenguaje formal?, Diferencia con los lenguajes naturales
2. Contestar verdadero (V) o falso (F):
a ) Σ∗ es un lenguaje formado por el alfabeto.
b ) La clausura de Kleene Σ∗ sobre el alfabeto Σ puede ser en algunos alfabetos un
conjunto nito.
c ) Dado
∪ el alfabeto Σ = {a,b} y ∆= {0,1}, la cadena w = a1b0 pertenece al alfabeto
Σ ∆
d ) Según la Jerarquía de Chomsky un lenguaje esta asociado un nivel de clasicación
de problemas asociado a una máquina
e ) Un algoritmo es el conjunto de instrucciones que puede calcular
f ) No existe un lenguaje innito L en el alfabeto Σ = {a,b} para el cual L sea diferente
a L* (L ̸= L*)
3. Sea A, B y C lenguajes de un alfabeto Σ. En cada una de los ítems siguientes se indican la
expresión de 2 lenguajes. Señale si son siempre iguales y justique (indique contraejemplos
en caso de ser apropiado)
∪ ∪
a ) A (B C) y AB AC
b ) A*B* y (AB)*
4. Enumere al menos 5 lenguajes (que no sean lenguajes de programación o idiomas) que
haya utilizado. Para cada uno de ellos identique el alfabeto y de ejemplo de una cadena
del lenguaje, describa el lenguaje.
14 CAPÍTULO 1. INTRODUCCIÓN
Capítulo 2
15
16 CAPÍTULO 2. LENGUAJES REGULARES Y AUTÓMATAS FINITOS
En los AFD debe cumplirse que: Para toda a que esta en Σ existe exactamente una transición
de salida de cada estado, es decir la función de transición dado un estado y un valor de entrada
se obtiene como resultado siempre un solo valor (estado).
Las siguientes son las tres formas para expresar y representar la función de transición, las
cuales son equivalentes entre si, cualquiera de ellas es suciente para completar el diseño del
AFD:
2. Función de transición: representada a través de una función. Una función asigna a cada
elemento de un conjunto (Conjunto Dominio) un elemento de otro conjunto (Conjunto
Rango o Codominio). Así la función f se denota f : A → B, siendo A el dominio y B
el rango. Por ejemplo, la siguiente función f(x)= x2 , se dene f: N → N, donde N es el
conjunto de los números naturales.
Los tipos de funciones son:
Estados Estados
Figura 2.2: Ejemplo de AFD: cadenas binarias que comienzan con cero
1
Dada f:A → B, la función inversa f −1 :B → A, se dene como f −1 (b) = {x | x en A y f(x) = b } para todo
b en B
18 CAPÍTULO 2. LENGUAJES REGULARES Y AUTÓMATAS FINITOS
2. Función de transición δ
δ(q0 , 0) = q1
δ(q0 , 1) = q2
δ(q1 , 0) = q1
δ(q1 , 1) = q1
δ(q2 , 0) = q2
δ(q2 , 1) = q2
Las tres representaciones del AFD son equivalentes y cada una de ellas es suciente para
expresar el modelo. Sin embargo, debe enterderse la relación entre ellas aunque se seleccione
solo una de ellas para representar al autómata.
1. Caso base para la cadena vacía λ: Para todo q en Q, δb(q,λ) = q. Esto quiere decir que
desde cualquier estado la cadena vacía λ no cambia el estado del AFD.
Por ejemplo: Dado el AFD anterior que reconoce el lenguaje sobre Σ = {0, 1} y L = {x | x en
Σ∗ y x comienza con 0}, pruebe si las cadenas w1 = 010 y w2 = 101 están en el lenguaje L:
1. δb(q0 ,010)
= δ(δ(qb 0 ,01),0)
= δ(δ(δ(qb 0 ,0),1),0)
= δ(δ(δ(δ(qb 0 , λ),0),1),0)
→ δ(δ(δ(q0 , 0), 1), 0) → (δ(q1 , 1), 0) → δ(q1 , 0) = q1 → Se acepta al terminar de procesar
la cadena 010 y quedar en un estado de aceptación δb(q0 ,010) = q1 (q1 está en F)
2.1. AUTÓMATAS DE ESTADOS FINITOS 19
2. δb(q0 ,101)
= δ(δ(qb 0 ,10),1)
= δ(δ(δ(qb 0 ,1),0),1)
= δ(δ(δ(δ(qb 0 , λ),1),0),1)
→ δ(δ(δ(q0 , 1), 0), 1) → (δ(q2 , 1), 0) → δ(q2 , 0) = q2 → No se acepta al terminar de pro-
cesar la cadena 101 y quedar en un estado que no es de aceptación δb(q0 ,101) = q2 (q2 no
está en F)
Cuadro 2.3: Tabla de transición: Lenguaje de las cadenas binarias que terminan en 01
δ 0 1
→ q0 {q0 , q1 } {q0 }
q1 ϕ {q2 }
* q2 ϕ ϕ
1. Caso base para la cadena vacía λ: δb(q,λ) = {q}. Es desde cualquier estado del autómata
la cadanea vacía λ no cambia de estado.
2. Paso recursivo para cadenas de cardinalidad mayor que 1: δb(q,xa) = { r | para algún p
en δb(q,x), δ (p,a) = r }. Sea w de la forma w = xa donde a es el símbolo nal (sujo de
longitud 1) de w y x el resto∪de w.
δb(q,x) = {p1 , p2 , ..., pn } sea ki=1 δ(pi ,a) = {r1 , r2 , ..., rn }
Entonces δb(q,x) = δ(δb(q,x),a) = {r1 , r2 , ..., rn }, ver gura 2.4.
La extensión∪ para δb de Q∗ xΣ:
δb((P,w) = qenP δb(q,w), para todo conjunto de estados P en Q∗
b 0 ,w) ∩
L(M) = { w | w en Σ∗ y δ(q F ̸= ϕ }
Es el conjunto de cadenas pertenecientes a Σ∗ tal que ejecutar el AFND desde el estado inicial
b 0 ,w) contiene al menos un estado de
q0 con la cadena w, la función de transición extendida δ(q
aceptación (es diferente del vacío la intersección con F).
Teorema 1. Si L es aceptado por un AFND entonces existe un AFD que acepta L (es decir,
ambos aceptan la misma clase de lenguaje: lenguajes regulares).
Algoritmo para la Construcción de Subconjuntos:
Este algoritmo permite a partir de un AFND obtener un AFD equivalente que reconoce el
mismo lenguaje. Su nombre se debe a que se intenta construir todos los subconjuntos del
conjunto de estados del AFND.
AFN N = (QN , Σ, δN , q0 , FN )
AFD D = (QD , Σ, δD , {q0 } , FD )
Tal que L(N) = L(D) (el lenguaje reconocido por el autómata N sea el mismo que el lenguaje
22 CAPÍTULO 2. LENGUAJES REGULARES Y AUTÓMATAS FINITOS
Cuadro 2.4: Tabla de transición δN : Lenguaje de las cadenas binarias que terminan en 01
δN 0 1
→ q0 {q0 , q1 } {q0 }
q1 ϕ {q2 }
* q2 ϕ ϕ
Ejemplo: Dado el AFDN de la gura 2.5 y el cuadro 2.4 denotado como N = (QN , Σ, δN , q0 ,
FN ), con Σ= {0,1} y QN = {q0 , q1 , q2 }, FN = {q2 }. Obtener D un AFD tal que L(N) = L(D)
a través del algoritmo de construcción de subconjuntos.
Figura 2.6: Relación AFDN y AFD: construcción de subconjunto sobre el AFND de la gura
2.5
1. Σ = {0, 1}
2. D = (QD , Σ, δD , {q0 }, FD )
3. QD = {ϕ, {q0 }, {q1 }, {q2 }, {q0 , q1 }, {q0 , q2 }, {q1 , q2 }, {q0 , q1 , q2 }} (Conjunto de todos los
subconjuntos de Q)
2.1. AUTÓMATAS DE ESTADOS FINITOS 23
Facilidad para modelar (autómatas más sencillos y con menos estados y transiciones).
λ-clausura(q1 ) = {q1 , q2 }
λ-clausura(q2 ) = {q2 }
∩
L(E)= { w | w en Σ∗ , δb(q0 ,w) F ̸= ϕ }
2.1. AUTÓMATAS DE ESTADOS FINITOS 27
Ejemplo: Dado el AFND-λ E de la gura 2.8, encontrar un AFD equivalente que reconozca
el mismo lenguaje.
E = (Q, Σ, δ , q0 , F), donde Q = {q0 , q1 , q2 }, Σ = {0, 1, 2} y F = {q2 }. Se obtiene el AFD D
= (QD , Σ, δD , q0D , FD ), aplicando el algorimos de construcción de subconjuntos de λ:
1. Σ = {0, 1, 2}
2. q0D = λ-clausura(q0 ) = {q0 , q1 , q2 }
3. QD = {ϕ, {q0 }, {q1 }, {q2 }, {q0 , q1 }, {q1 , q2 }, {q0 , q2 }, {q0 , q1 , q2 }}
4. FD = {{q2 }, {q1 , q2 }, {q0 , q2 }, q0 , q1 , q2 }
5. Cálculo de δD : (ver cuadro 2.7)
Para el estado inicial {q0 , q1 , q2 } se aplica la∪denición∪para todos los elementos de Σ: ∪ ∪
* δD ({q0 , q1 , q2 },0) = λ-clausura(δE (q0 , 0) δE (q1 , 0) δE (q2 , 0)) = λ-clausura({q0 } ϕ ϕ)
= λ-clausura({q0 }) = λ-clausura(q0 ) = {q∪0 , q1 , q2 } ∪ ∪ ∪
* δD ({q0 , q1 , q2 },1) = λ-clausura(δE (q0 , 1) δE (q1 , 1) δE (q2 , 1)) = λ-clausura(ϕ {q1 } ϕ)
= λ-clausura({q1 }) = λ-clausura(q1 ) = {q∪1 , q2 } ∪ ∪ ∪
* δD ({q0 , q1 , q2 },2) = λ-clausura(δE (q0 , 2) δE (q1 , 2) δE (q2 , 2)) = λ-clausura(ϕ ϕ {q2 })
= λ-clausura({q2 }) = λ-clausura(q2 ) = {q2 }
Para el estado {q1 , q2 } se aplica la denición
∪ para todos los elementos
∪ de Σ:
* δD ({q1 , q2 },0) = λ-clausura(δE (q1 , 0) δE (q2 , 0)) = λ-clausura(ϕ ϕ) = λ-clausura(ϕ)
=ϕ ∪ ∪
* δD ({q1 , q2 },1) = λ-clausura(δE (q1 , 1) δE (q2 , 1)) = λ-clausura({q1 } ϕ) = λ-
clausura({q1 }) = λ-clausura(q1 ) = {q1 , q∪ 2} ∪
* δD ({q1 , q2 },2) = λ-clausura(δE (q1 , 2) δE (q2 , 2)) = λ-clausura(ϕ {q2 }) = λ-
clausura({q2 }) = λ-clausura(q2 ) = {q2 }
Para el estado {q2 } se aplica la denición para todos los elementos de Σ:
* δD ({q2 },0) = λ-clausura(δE (q2 , 0)) = λ-clausura(ϕ) = ϕ
* δD ({q2 },1) = λ-clausura(δE (q2 , 1)) = λ-clausura(ϕ) = ϕ
* δD ({q2 },2) = λ-clausura(δE (q2 , 2)) = λ-clausura({q2 }) = λ-clausura(q2 ) = {q2 }
Hay dos formas de interpretar la construcción de subconjuntos-λ, una para crear un AFD y
otra AFND. La idea es llegar a un AF más fácil de implementar (es decir obtener un AFD).
AFD: Se toma cada estado como un conjunto de etiquetas. Ver gura 2.12
AFND: Se interpreta el contenido de la etiqueta de cada estado. Ver gura 2.13
2.1. AUTÓMATAS DE ESTADOS FINITOS 29
Figura 2.12: AFD equivalente del AFND-λ de la gura 2.8 a través de la Construcción de
subconjuntos λ
Figura 2.13: AFND equivalente del AFND-λ de la gura 2.8 a través de la Construcción de
subconjuntos λ
FIN
Función transicionδ (Estado q, Símbolo a): Estado
Estado S
Selección
q = q0 y a = 0: S = q1
q = q0 y a = 1: S = q2
q = q1 y a = 0: S = q1
q = q1 y a = 1: S = q1
q = q2 y a = 0: S = q2
q = q2 y a = 1: S = q2
fin Selección
Retornar S
fin Función
Donde se asume que se tiene los siguientes tipos de datos: Conjunto (paramétrico por el
tipo de elemento), Estado, Simbolo. Para ellos se tiene las siguientes operaciones:
LeerSimboloCadena() que permite obtener desde la entrada estándar un Símbolo de la
cadena de entrada w (desde el comienzo, secuencialmente uno a uno)
Imprimir(CadenaCaracter) función que permite imprimir la salida del autómata, si
acepta o no la cadena de entrada
Pertenece(Estado A, Conjunto B[Estado]), es una operación del tipo de dato Con-
junto que determina si el elemento A (del tipo Estado) pertenece al Conjunto de Estados
B.
Una posible implementación del algoritmo anterior en lenguaje C se muestra a continuación:
#include <iostream>
#include <string>
#include <stdio.h>
using namespace std;
enum estados { q0, q1, q2 };
void transicion(enum estados *estado, char a) // función de transición
{
switch(*estado) {
case q0:
if(a == '0') {
2.1. AUTÓMATAS DE ESTADOS FINITOS 31
putchar(a);
*estado = q1;
}
else {
if(a == '1') {
putchar(a);
*estado = q2;
}
}
break;
case q1:
if(a == '0' || a == '1') {
putchar(a);
*estado = q1;
}
break;
case q2:
if(a == '0' || a == '1') {
putchar(a);
*estado = q2;
}
break;
}
}
int main()
{
char c;
string cad;
enum estados state = q0;
cout << "AFD que reconoce todas las cadena binarias que comienzan con 0" << endl;
cout << "Estado inicial: " << state << endl;
c = getchar();
cad = c;
while((c == '0') || (c == '1')) {
transicion(&state, c);
cout << " Estado actual: " << state << endl;
c = getchar();
if ((c == '0') || (c == '1')) cad = cad + c;
}
if (state == q1) cout << "La cadena " << cad << " SI esta en el lenguaje" << endl;
else cout << "La cadena " << cad << " NO esta en el lenguaje" << endl;
return 0;
}
32 CAPÍTULO 2. LENGUAJES REGULARES Y AUTÓMATAS FINITOS
son diferentes en todo sentido y por tanto no son iguales. Sin embargo, estos autómatas
diferentes, M1 ̸= M2 , son capaces de procesar cadenas de Σ∗ y reconocer el mismo
lenguaje L (todas y cada una de las cadenas que forman a L, ni una más ni una menos),
en ese caso son llamados autómatas equivalentes, es decir L(M1 ) = L(M2 ).
Ejercicios resueltos
1. Determine las diferencias entre un AFD y un AFND. Ver el cuadro 2.8
2. Aplicaciones de la vida real que pueden ser vistos como AF. Algunas aplicaciones intere-
santes de los AF están referidas al almacenamiento de diccionarios como los usados en
los celulares, en la que se utilizan sus características para hacer búsquedas, inserciones o
modicaciones rápidas. Así como también para mejorar el ordenamiento y búsqueda en
otros tipos de aplicaciones como los circuitos digitales, texto, secuencias lógicas de fun-
cionamiento (como la maquinaria industrial, robótica) y otras. También son útiles para
el modelado de aquellos casos en los que a partir de una acción anterior se puede llegar a
un conjunto determinado de destinos, pero no se tiene certeza anticipada de cuál de ellos
es el indicado, utilizados para modelar protocolos de comunicación, sistemas distribuidos,
planicación, etc.
Existen palabras propias del lenguaje (palabras reservadas) que no pueden ser usadas
como identicadores ej: if, do, while, etc. Cómo puede modicar el AF anterior para no
considerar como identicadores a las palabras reservadas del lenguaje.
34 CAPÍTULO 2. LENGUAJES REGULARES Y AUTÓMATAS FINITOS
Se plantea como ejercicio pensar cómo puede modicar el AF de la gura 2.15 para reconocer
lo siguiente: cambiar el uso del punto para que en su lugar la coma (,) se utilice para separar
enteros y decimales, y el punto (.) se emplee como separador de las unidades decimales (co-
menzando desde el lado derecho de tres en tres). Por ejemplo, partes enteras de las literales
numéricas como: 1.300 o 35.413 o 38 o 23.300.080, etc.
Ejercicios propuestos
1. Para Σ = {0,1} construya un AFD que acepte los siguientes lenguajes:
a ) El conjunto de cadenas que tiene 011 como subcadena.
b ) El conjunto de todas las cadenas cuyo tercer elemento desde el extremo izquierdo
sea un 1.
c ) El conjunto de cadenas en las que el número de ceros es divisible por 3.
d ) El conjunto de cadenas que terminan con 01.
e ) El conjunto vacío.
f ) El conjunto de la cadena vacía.
2. Constuya un AF para los siguientes lenguajes:
a ) El conjunto de cadenas basadas en Σ={a,b,c} cuyo último símbolo no haya apare-
cido antes en la misma entrada.
36 CAPÍTULO 2. LENGUAJES REGULARES Y AUTÓMATAS FINITOS
39