6 Ejercicios resueltos de AFD y AFP

6 EJERCICIOS RESUELTOS
(por la Prof. Ana Díaz Bott)
CAP. 1: INTRODUCCIÓN A AFs Y APLICACIONES
* Ejercicio 1 * (pág.7)
(a) SI
(b) NO
(a) SI
(b) SI
(a) T a b
0- 1 -
1+ - 2
2 3 -
3+ - -
(b)
palabra ab: 0- => a => 1 => b => 2+ RECONOCE
cadena a: 0- => a => 1 => RECHAZA (porque no es un estado final)
cadena abab: 0- => a => 1 => b => 2 => a => ?? RECHAZA (no puede
continuar)
cadena baa: 0- => b => ?? RECHAZA (no puede continuar)
cadena vacía: 0- => ε => ?? RECHAZA (el estado inicial no es final)
ER = 01 + 10
(a) T a b
0- 0 1
1 2 1
2+ - -
(b)
palabra ba: 0- => b => 1 => a => 2+ RECONOCE
palabra abba: 0- => a => 0 => b => 1 => b => 1 => a => 2+ RECONOCE
palabra aaba: 0- => a => 0 => a => 0 => b => 1 => a => 2+ RECONOCE
palabra aabba: 0- => a => 0 => a => 0 => b => 1 => b => 1 => a => 2+
RECONOCE
cadena a: 0- => a => 0 => ?? RECHAZA (el estado incial no es final)
cadena ab: 0- => a => 0 => b => ?? RECHAZA (el estado 1 no es final)
(a) T a b c d
0-+ 0 0 0 0
(b) palabra a: 0- => a => 0+ RECONOCE
palabra bcda: 0- => b => 0 => c => 0 => d => 0 => a => 0+ RECONOCE
palabra ccc: 0- => c => 0 => c => 0 => c => 0+ RECONOCE
palabra vacía: 0- => ε => 0+ RECONOCE
SSL 2 - EJERCICIOS RESUELTOS 2 Muchnik
(a) T a b
0- 1 -
1 2 -
2 - 3
3+ 2 -
(b) palabra aab: 0- => a => 1 => a => 2 => b=> 3+ RECONOCE
palabra aabab: 0- => a => 1 => a => 2 => b => 3 => a => 2 => b => 3+
RECONOCE
cadena a: 0- => a => 1 => ?? RECHAZA (el estado 1 no es final)
cadena ba: 0- => b => ?? RECHAZA (no puede continuar)
DF = ({0, 1, 2, 3}, {a, b,c}, TT, 0, {3}) donde la TT es:
TT a b c
0- 1 1 1
1 2 2 2
2 3 3 3
3+ 3 3 3
(a) DF = ({0,1,2,3}, {a,b,c}, TT, 0, {2,3})
TT a b c
0- 1 4 4
1 4 3 2
2+ 4 4 4
3+ 3 4 4
4 4 4 4
(b) ER = ac + aba*
(c) Describa las actividades de este AFD para todos los casos posibles.
(a) Sea: S= {+, -} D = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} O =
{ASCII – (S, D)}
TT S D O
0- 1 2 3
1 3 2 3
2+ 3 2 3
3 3 3 3
(b) Recorra el Algoritmo 1 para la cadena –1234;
(c) Recorra el Algoritmo 1 para la cadena 12*34.
(d) Opcional.
(e) Opcional.
-123,01234567,+1234123
Son palabras porque son una secuencia de caracteres que reoresentan los
números enteros con y sin signo.
No. Porque tienen un significado diferente. fdt marca el fin del texto y
# marca el fin de cada cadena que debe ser procesada.
CAP. 2: AUTÓMATAS FINITOS CON PILA
a) No es un LR porque los caracteres del alfabeto son dependientes entre
si; están en función de la variable n.
b) Demuestre que las producciones dadas en el Ejemplo 1 generan a L1.
Sea la cadena aabb: Sea la cadena ab: Sea la cadena
aaabbb:
S S S
aSb ab Reconoce aSb
aabb Reconoce aaSbb
aaabbb
Reconoce
El ε significa que el AFP, estando en el estado 4 y no leyó ningún
carácter, hace un pop del símbolo Z y pasa al estado 5 haciendo un push,
primero de P y luego de R, quedando este último símbolo como nuevo tope
de la pila.
Reconocer por fin de la cadena significa que cuando detecta el fdc y la
pila está vacía, transita al estado final. Reconocer por pila vacía
significa que el conjunto de estados finales es vacío.
SÍ.
Elimina el símbolo que está en el tope de la pila.
La 7-upla M = (E, A, A', T, e0, p0, F), donde:
– E = {e0, e1, e2, e3}
– A = {a,b} y fdc para indicar el final de la cadena.
– A' = {R,$}
– e0
– p0 = $
– F = {e3}
– T es:
TM a b fdc
e0,$ | e1,R$
e1,R | e1,RR e2,
e2,R | e2,
e2,$ | e3,$
a)
e0,$ => a => e1,R$
e1,R => a => e1,RR
e1,R => a => e1,RR
e1,R => b => e2,
e2,R => b => e2,
e2,R => b => e2,
e2,$ => fdc => e3,$ RECONOCE
b)
e0,$ => a => e1,R$
e1,R => a => e1,RR
e1,R => b => e2,
e2,R => b => e2,
e2,$ => b => ?? (la pila está vacía, leyó una b y no tiene, en el tope
de la pila, un símbolo R para sacar => RECHAZA
– E = {e0, e1, e2}
– A' = {R,$}
– e0
– p0 = $
– F = { }
– T es:
TM a b fdc
e0,$ | e1,R$
e1,R | e1,RR e2,
e2,R | e2,
e2,$ | e2,
a) e0,$ => a => e1,R$
e1,R => a => e1,RR
e1,R => a => e1,RR
e1,R => b => e2,
e2,R => b => e2,
e2,R => b => e2,
e2,$ => fdc => e2, RECONOCE
b) e0,$ => a => e1,R$
e1,R => a => e1,RR
e1,R => b => e2,
e2,R => b => e2,
e2,$ => b => e2, ?? en la pila se hace un pop, por lo tanto, la pila
no tiene ningún símbolo, se lee una b, sigue en el estado e2 pero
no tiene símbolo para hacer otro pop => RECHAZA
– E = {e0, e1, e2, e3}
– A' = {R,$}
– e0
– p0 = $
– F = {e3}
– T es:
TM a b fdc
e0,$ | e1,R$
e1,R | e1,RR e2,R
e2,R | e2,
e2,$ | e3,$
– E = {e0, e1, e2, e3, e4}
– A' = {R,$}
– e0
– p0 = $
– F = {e4}
– T es:
TM a b fdc
e0,$ | e1,$
e1,$ | e2,R$
e2,R | e2,RR e3,
e3,R | e3,
e3,$ | e4,$
– E = {e0, e1, e2, e3, e4, e5}
– A' = {R,$}
– e0
– p0 = $
– F = {e5 }
– T es:
TM a b fdc
e0,$ | e1,R$
e1,R | e1,RR e2,R
e2,R | e3,
e3,R | e2,R
e3,$ | e4,$ e5,$
e4,$ | e4,$ e5,$
– E = {e0, e1, e2}
– A' = {R,Z,$}
– e0
– p0 = $
– F = {e2 }
– T es:
TM a b fdc
e0,$ | e1,R$ e1,Z$
e1,R | e1,RR e1,ε
e1,Z | e1,ε e1,ZZ
e1,$ | e1,R$ e1,Z$ e2,$
(Ejemplo 6) La 7-upla M = (E, A, A', T, e0, p0, F), donde:
– E = {e0, e1, e2, e3}
– A = {4,+, *, (, )} y fdc para indicar el final de la cadena.
– A' = {R,$}
– e0
– p0 = $
– F = {e3 }
– T es:
_TM______ 4 +,* ( ) fdc
e0,$ | e1,$ e0,R$
e0,R | e1,R e0,RR
e1,$ | e1,$ e0,$ e3,$
e1,R | e1,R e0,R e2,
e2,$ | e0,$ e3,$
e2,R | e0,R e2,
e3,$ |
a) e0,$ => ( => e0,R$
e0,R => ( => e0,RR
e0,R => 4 => e1,R
e1,R => ) => e2,ε
e2,R => ) => e2,ε
e2,$ => fdt => e3,$ RECONOCE
b) 4 + 4
c) 4 + 4 * (4 + (4))
d) e0,$ => 4 => e1,$
e1,$ => + => e0,$
e0,$ => ( => e0, R$
e0, R => ( => e0,RR
e0,R => 4 => e1,R
e1,R => ) => e2,ε
e2,R => ) => e2,ε
e2,$ => ) => ?? se lee un ), sigue en el estado e2 , la pila
está vacía, por lo tanto no tiene símbolo para
hacer un pop => RECHAZA
Porque el lenguaje de las expresiones es un LF Infinito No Regular y, por
lo tanto, no es posible encontrar una GR que permita describir a este
lenguaje.
CAP. 3: INTRODUCCIÓN AL PROCESO DE COMPILACIÓN

Es un programa que convierte un programa fuente en otro.
La marca de fin de archivo.
Qué realicen la misma tarea.
LEXEMA TOKEN
int palabraReservada
WHILE Identificador
; caracterPuntuacion
while palabraReservada
( carácterPuntuación
WHILE Identificador
; carácterPuntuación
> operador
32 constante
) carácterPuntuación
- operador
2.46 constante
Desde la visión del programador, hay dos errores sintácticos: la doble
declaración de la variable a(como int y como double) y el return 12
porque la función es void.
Son tokens.
La doble declaración de la variable a y el return 12.
El alcance de una variable está dado por el contexto en el cual tiene
validez. (por ejemplo: una variable local a una función, su alcance está
limitado a la función, es decir, fuera de ella no existe).
a) “Expresión es infija” por ejemplo, cuando un operador es binario debe
estar entre dos operandos.
b) ID es un noterminal.
c) fin es una palabra reservada; Fin y finn son identificadores.
d) Significa que no hay que declarar a los identificadores porque son del
único tipo de dato entero y tienen todos una longitud igual a 323
caracteres.
LEXEMA TOKEN
inicio palabraReservada
leer palabraReservada
a identificador
, carácterPuntuación
b identificador
cc identificador
:= asignación
a identificador
+ operador
b identificador
- operador
2 constante
escribir palabraReservada
cc identificador
, carácterPuntuación
a identificador
+ operador
4 constante
fin palabraReservada
a) conjunto de noterminales: <token>, <identificador>, <constante>,
<palabraReservada>, <operadorAditivo>, <asignación>,
<carácterPuntuación>, <identificador>, <letra>, <dígito>, <constante>.
conjunto de terminales: a-z A-Z 0-9 inicio fin leer escribir + -:= ( )
, ;
conjunto de metasímbolos: < > -> uno de { } o una de
b) Se produce un error léxico.
a) conjunto de noterminales: <programa>, <listaSentencias>, <sentencia>,
<identificador>, <expresión>, <listaIdentificadores>,
<listaExpresiones>, <primaria>, <operadorAditivo>, <constante>
conjunto de terminales: inicio fin leer escribir := ; , ( )
conjunto de metasímbolos: < > -> { } |
b) inicio
leer (x,y);
escribir (x-9, y +x);
fin
d) Los símbolos := No representan a un operador porque no pertenece
al token asignación.
a) una máquina virtual es una máquina que representa lo que hace una
computadora y tiene su propio lenguaje de máquina.
b) “en tiempo de compilación”: durante el proceso de compilación.
c) “en tiempo de ejecución”: durante la ejecución del programa
ejecutable.
d) se compila el programa fuente.
e) se ejecuta el programa objeto escrito en lenguaje de máquina.
f) SÍ. Son equivalentes el programa que se compila y el programa que se
ejecuta.
SÍ. La genera la Gramática Léxica.
4 caracteres que puedan actuar como centinelas para un identificador en
Micro: - + : ,
* Ejercicio 18* (pág.41)

Porque no pertenece al alfabeto (la gramática se construye sobre un
alfabeto).
abc identificador * error léxico ab identificador
a) los ignora
b) forman parte del literalCadena
c) ' ' '\n' son constantes carácter.
a) contenido que queda en la Tabla de Símbolos una vez que el Análisis
Léxico haya finalizado:
inicio PR
fin PR
leer PR
escribir PR
a ID
b ID
b) Se fija en la TS.
Aclaración: la numeración corresponde al orden en el cual se va armando
el AAS.
(1) <objetivo>
(2) <programa> (29) FDT
(3) INICIO (4) <listaSentencias> (28) FIN
(5) <sentencia> (12) <sentencia>
(6) ID (7) ASIGNACION (8) <expresión> (11) PUNTOYCOMA
(9) <primaria>
(13) ESCRIBIR (14) PARENIZQUIERDO (15) <listaExpresiones> (26)PARENDERECHO(27) PUNTOYCOMA
(10) CONSTANTE
(16) <expresión> (19) COMA (20)<expresión>
(17) <primaria> (21)<primaria> (23)OPERADORADITIVO (24)<primaria>
(18) ID (22) ID (25)CONSTANTE
void Programa (void) {
/* <objetivo> -> <programa> FDT */
Match(INICIO);
ListaSentencias();
Match(FIN);
}
Match(), ProximoToken() y ErrorSintactico().
a) inicio escribir(4); fin
b) Objetivo()
Programa()
ListaSentencias()
Sentencia()
ListaExpresiones()
Expresion()
Primaria()
En el parámetro: resultado es una variable de tipo puntero a un objeto de
tipo REG_EXPRESION.
En la sentencia: significa que en lo apuntado por resultado (*resultado)

guarde el contenido de la variable operandoIzq. Aquí el asterisco
corresponde al operador indirección.
* Ejercicios Adicionales * (pág.49)

void ListaExpresiones(void) {
/* <listaExpresiones> -> <expresión> {COMA <expresión> } */
Expresion(); /* la primera de la lista de expresiones */
while(1) { /* un ciclo indefinido */
switch(ProximoToken()) {
case COMA: Match(COMA); Expresion(); /* procesa la secuencia
opcional */
default: return;
} /* fin-switch */
} /* fin-while */
}
void Primaria(void) {
/*
<primaria> -> ID | CONSTANTE | PARENIZQUIERDO <expresión> PARENDERECHO
*/
TOKEN tok = ProximoToken();
switch(tok) {
case ID: Match(ID); break;
case CONSTANTE: Match(CONSTANTE); break;
case PARENIZQUIERDO: Match(PARENIZQUIERDO); Expresion();
Match(PARENDERECHO); break;
default:
ErrorSintactico(tok); break;
} /* fin-switch */
}
Cap. 4: ANÁLISIS LÉXICO, ANÁLISIS SINTÁCTICO Y ANÁLISIS SEMÁNTICO
(XX, función, int, 1, double)

(a, parámetro,double)
(s, arreglo, 1, char, 12)
(b, variable, double)
Identificadores, constantes (reales, enteras).
a) V
b) F
c) F
d) V
a) SI
b) NO
c) SI
d) SI
e) SI
f) NO
g) SI
h) NO
El de ANSI C.
El Scanner lee el primer carácter que es una / (barra), lee el sengundo
carácter, si es una barra, entonces lee el tercer carácter, si este
último es el símbolo +, entonces detecta el operador //+ y no
necesita leer un próximo carácter; en caso de ser cualquier otro
carácter, detecta el operador // y si después de leer el primer
carácter (barra), el segundo es cualquier otro carácter, entonces detecta
el operador /.
Para facilitar el Análisis Sintáctico.
a) En el primer caso, el Scanner retorna el tipo de constante numérica y
la posición de esa constante guardada como secuencia de caracteres (sin
convertir); en cambio, en el 2º caso, el Scanner debe realizar una
conversión de la secuencia de caracteres que representan a la constante
entera a su valor numérico y entonces retorna el tipo de constante
numérica y el valor de la constante.
b) por enumeración o con un número entero.
(tipo, valor), o sea: (CONSTANTECARACTER, carácter)
SÍ.
SÍ.
a) typedef PR, char PR, strings ID, [ CP (carácterpuntuación),
200 CONSTANTE, ] CP, [ CP, 32 CONSTANTE, ] CP, ; CP
b) (strings, nombredetipo, arreglo, 2, char, 200, 32)
Aclaración: nombredetipo será un valor que indique que strings no es
el nombre de una variable sino el nombre de un tipo de dato.
En literalCadena y como carácter constante.
a) noterminales: inst. asignación identif. expr. const.
terminales: posicion = inicial + velocidad * 60
b) axioma
c) falta el ; (punto y coma)
d) posicion = inicial + velocidad * 60;
e) inst. asignación
identif. = expr. ;
posicion = expr. ;
posicion = expr. + expr. ;
posicion = identif. + expr. ;
posicion = inicial + expr. ;
posicion = inicial + expr. * expr. ;
posicion = inicial + identif. * expr. ;
posicion = inicial + velocidad * expr. ;
posicion = inicial + velocidad * const. ;
posicion = inicial + identif. * 60;
NO.
En Pascal: variable no declarada, variable declarada con dos tipos
distintos..
En ANSI C: función no definida, cuando en el lado izquierdo de una
asignación aparece un valor constante (ejemplos: 1 = 3; 4++;).
a) noterminales: listaExpresiones expresión término factor
terminales: num + * ; ( )
metasímbolos: : |
Ejemplo: S -> aTbRba | aTbc
if ( <condición> ) <sentencia> es α
β1 else <sentencia>
β2 ε
S -> aTbS’
S’ -> Rba | c
T -> a | Ta
R -> cR’
R’ -> ε | Rb
<listaExp> -> <operando> <listaExp>’
<listaExp>’ -> ε | <operador> <operando> <listaExp>’
GIC 2:
listaExpresiones: expresión listaExpresiones’
listaExpresiones’: ε | ; expresión listaExpresiones’
expresión: término expresión’
expresión’: ε | + término expresión’
término: factor término’
término’: ε | * factor término’
factor: num | ( expresión )
Primero(S) = Primero (aSe) U Primero(B)
{a} U Primero(bBe) U Primero(C)
{b} U Primero(cCe) U Primero(d)
{c} U {d}
Primero(B) = Primero(bBe) U Primero(C)
{b} U Primero(cCe) U Primero(d)
{c} U {d}
Primero(C) = Primero(cCe) U Primero(d)
{c} U {d}
Primero(S) = Primero(ABc)
como A es un noterminal, por (2), entonces hay que calcular los conjuntos
Primero para cada lado derecho de A:
A -> a|ε esto implica que Primero(a) = {a} U Primero(ε) = {ε}
pero como A puede generar ε, por (3), entonces Primero(S) depende de B
(X2) y como B es un noterminal, por (2), hay que calcular los conjuntos
Primero para cada lado derecho de B:
B -> b|ε esto implica que Primero(b) = {b} U Primero(ε) = {ε}
pero como B puede generar ε por (3), entonces Primero(S) depende de c,
y como c es un terminal, por (1), Primero(c) = {c}.
Por lo tanto:
Primero(S) = {a,b,c}
b) Porque no está descripto en la GIC.
c) Porque no existe.
Predice (E1 -> T1 E2) = Primero(T1 E2) = {(, num} porque no contiene a ε
y, por lo tanto, Predice coincide con Primero(T1 E2).
Dos.
a) noterminales: listaParéntesis, plista
terminales: ( ) ε
b) listaParéntesis
plista
( listaParéntesis )
( plista )
( ε )
( )
c) listaParéntesis
plista
( listaParéntesis )
( plista listaParéntesis )
( ( listaParéntesis ) listaParéntesis )
( ( plista) listaParéntesis )
1º) no es recursiva a izquierda;
2º) no tiene prefijo común.
a) Detecta cada lexema y retorna el token correspondiente, en la medida
que el Parser se lo solicita.
b) Realiza el Análisis Sintáctico de la expresión en base a la GIC.
c) Detecta que la primera constante es entera (int) y que la segunda
constante es real (double), y realiza la conversión a double para poder
hacer la operación de suma.
a) Análisis Léxico: Detecta cada lexema y retorna el token correspon-
diente, en la medida que el Parser se lo solicita. No hay errores
léxicos.
b) Análisis Sintáctico: Analiza sintácticamente el bloque y no detecta
errores sintácticos.
c) Análisis Semántico: 1º) detecta que la variable a es entera (int); 2º)
detecta que el valor constante 2 no es un valorL en la sentencia de
asignación –detección del 1er. error; 3º) detecta que después de la
sentencia de asignación hay una declaración de la variable b como real
(double) y que la misma está fuera de lugar -detecta el 2º error; 4º)
detecta que la variable b, en la sentencia de asignación, es un valorL
(correcto) y que en la expresión 4++, 4 es un valor constante y se le
aplica el operador incremento -detecta el 3er. error porque el operando
debe ser un valorL.
a) Análisis Léxico: Detecta cada lexema y retorna el token correspon-

diente, en la medida que el Parser se lo solicita. No hay errores
léxicos.
b) Análisis Sintáctico: Analiza sintácticamente el bloque y no detecta
errores sintácticos.
c) Análisis Semántico: Detecta que las variables a y b son enteras (int)
y que c es una variable real (double); realiza la conversión correspon-
diente a double para poder hacer la operación de suma, luego quedará el
resultado truncado (porque la suma se realiza double pero el resultado es
int).

6 Ejercicios resueltos de AFD y AFP

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

6 Ejercicios resueltos de AFD y AFP

Cargado por

Copyright:

Formatos disponibles

6 EJERCICIOS RESUELTOS

(por la Prof. Ana Díaz Bott)

CAP. 1: INTRODUCCIÓN A AFs Y APLICACIONES

CAP. 2: AUTÓMATAS FINITOS CON PILA

CAP. 3: INTRODUCCIÓN AL PROCESO DE COMPILACIÓN

* Ejercicio 18* (pág.41)

(2) <programa> (29) FDT

(3) INICIO (4) <listaSentencias> (28) FIN

(5) <sentencia> (12) <sentencia>

(6) ID (7) ASIGNACION (8) <expresión> (11) PUNTOYCOMA

(13) ESCRIBIR (14) PARENIZQUIERDO (15) <listaExpresiones> (26)PARENDERECHO(27) PUNTOYCOMA

(16) <expresión> (19) COMA (20)<expresión>

(17) <primaria> (21)<primaria> (23)OPERADORADITIVO (24)<primaria>

(18) ID (22) ID (25)CONSTANTE

En la sentencia: significa que en lo apuntado por resultado (*resultado)

* Ejercicios Adicionales * (pág.49)

Cap. 4: ANÁLISIS LÉXICO, ANÁLISIS SINTÁCTICO Y ANÁLISIS SEMÁNTICO

(XX, función, int, 1, double)

a) Análisis Léxico: Detecta cada lexema y retorna el token correspon-

También podría gustarte