LENGUAJES Y

TRADUCTORES

G.L.C Y AUTOMATAS CON PILA

Profesor: Carlos A. Ruiz De La Cruz Melo

Correo: cruizdelacruzm@unmsm.edu.pe
EJERCICIO 1
Escriba la gramática para el
siguiente lenguaje:
EJERCICIO 2
Escriba la gramática para el
siguiente lenguaje:

S→ABC
A→0A1
A→01
B→1B2
B→12
B→&
C→3C
C→3
EJERCICIO 3
Escriba la gramática para el
siguiente lenguaje:

S→ABC
A→0A1
A→&
B→1B2
B→&
C→3C
C→3
EJERCICIO 4
Escriba la gramática para el
siguiente lenguaje:

S→AB
A→aAcc
A→G
G→bG
G→&
B→dddB
B→&
AUTOMATA DE PILA(AP)
Definición
❑ Autómata que extiende la potencia reconocedora de
lenguajes del autómata finito añadiendo una memoria
interna tipo pila (“contador de simbolos”).

❑ El funcionamiento del AP se realiza de acuerdo con

alguna forma de gramática.

PILA
Push(3) Push(5) Push(1) Pop Pop Push(2)
1
5 5 5 2
3 3 3 3 3 3
AP
Definición formal
AP={ E, , p, , 0, P0, F }

E : conjunto finito de estados

 : alfabeto del sistema
p : alfabeto de la pila
 : función de transición
0 E : estado inicial
P0  p : estado inicial de la pila
F E : conjunto de estados finales
AP
Configuración de un AP

(i , w, a)

Donde:
i : estado actual del AP
w :Subcadena por analizar en el instante T
a :Contenido de la pila en el instante T

❑ w y a pueden ser la secuencia 

❑ Si w =  no hay nada mas por analizar
❑ Si a =  la pila no tiene nada, esta vacía
AP
Movimiento en un AP

Transición entre dos configuraciones

(i , aw, pa) → (j , w, ua)

Movimiento válido si (j , u)  (i , a, p)

Donde:
i , j E a    {}
w  * u  p
AP
(q , ab…, zxy..) → (p , b, xy..)

••• a b •• • ••• a b •• •

z x
q x p y
y :
:
SECUENCIA ACEPTADA
Configuración inicial (0 , w, P0) w

Configuración final (f , , a) f F a  p*

Un AP acepta una secuencia w si

puede llegarse de la configuración
inicial a la configuración final:

(0 , w, P0) →* (f , , a)

LENGUAJE ACEPTADO

El lenguaje es aceptado por el AP

cuando se llega al estado final que
se denota por:

L(AP)={ w  */ (0 , w, P0) →* (f , , a), f F }

Ejemplo 1 x, ; x

Construimos un AP :
AP={ E, , p, , 0, P0, F }

E = { 0 }
0
 = { x, y }
p = {x}
0 E : estado inicial y, x ; 
x  p : estado inicial de la pila
F = { 0 }

1.(0 , x,  ; 0 , x ) push

2.(0 , y, x ; 0 ,  ) pop
Ejemplo 1 x, ; x

1.(0 , x,  ; 0 , x ) push

2.(0 , y, x ; 0 ,  ) pop 0

y, x ; 

CORRECTOS INCORRECTOS
yxyx xyy
xyxy xxyyy
xy yy
yx
xxy
xxy
y
Ejemplo 1
1.(0 , x,  ; 0 , x ) push

2.(0 , y, x ; 0 ,  ) pop

x, ; x

a) (0 , xy, ) b) (0 , yxyx, x) c) (0 , yxx, x)

0 1 2 2
(0 , y, x) (0 , xyx, ) (0 , xx, )
2 1 1
(0 , , ) (0 , yx, x) (0 , x, x)
y, x ;  2 1
(0 , , xx)
(0 , x, )
1
(0 , , x)
AP
Configuración inicial 1.(0 , x,  ; 0 , x ) push

2.(0 , y, x ; 0 ,  ) pop

yxyx

(0 , yxyx, x)
x

(0 , xyx, ) (0 , yx, x) (0 , x, ) (0 , , x)

y x y x y x y x y x y x y x y x

0 0 x 0 0 x
 x, ; x
Ejemplo 1 push

Secuencia que no pertenece al

lenguaje
0
(0 , xyyx, )
1
(0 , yyx, x)
pop y, x ; 
2
(0 , yx, )

?
1.(0 , x,  ; 0 , x )
Observacion 2.(0 , y, x ; 0 ,  )
No existe transición alguna para poder
continuar y aceptar la secuencia como
parte del lenguaje.
 Ejemplo 1 bool reconocedor(char x[]){
strcpy(vector,x);
int e=0;
int j=0;
char temp;

Programa
while(j<strlen(vector)){
switch(e){
case 0:
if(vector[j]=='x'){
METER('x');
class ARREGLO{ }
char vector[100]; else {
char pila[100]; if(!VACIO()){
int i,tope; temp=SACAR();
public: if(vector[j]=='y' && temp=='x'){ ;}
ARREGLO(char m[]){ tope=100;strcpy(pila,m);i=strlen(pila);} else e=3;
bool OCUPADO(){ }
if (i>=tope) else e=3;
return true; }
else return false; break;
} }
bool VACIO(){ j++;
if(i<=0) return true; }//fin de while
else return false; if(e==0) return true;
} else return false;
}
void METER(char a){ };
char t[2]; int main(){
t[0]=a;t[1]='\0'; char cadena[100];
strcat(pila,t); char pila[100];
i=strlen(pila); cout<<"\n INGRESE CADENA A RECONOCER: ";cin>>cadena;
} cout<<"\n INGRESE PILA : ";cin>>pila;
char SACAR(){ if(!strcmp(pila,"v")) strcpy(pila,"");
char a; ARREGLO tira(pila);
int k=strlen(pila); if(tira.reconocedor(cadena))
a=pila[k-1]; cout<<"\n verdadero";
pila[k-1]='\0'; else cout<<"\n falso";
i=strlen(pila); getch();
return a; }
}
Ejemplo 2

Construir un AP que reconosca el siguiente

lenguaje:

L(G)={ ={x, y} / w=xn  w=yn donde n=2 }

Secuencias reconocidas por el lenguaje:

yy, xx

Secuencias no reconocidas:
x, y, yyxx, xyyx , xyyxx
Ejemplo 2 ,x;
Construimos el AP : x,x;
x, ;x
AP={ E, , p, , 0, P0, F }
1 2
E = { 0 } 0
 = { x, y } y,y;
y,;y
p = { x, y }
,y;
0 E : estado inicial
  p : estado inicial de la pila
F = { 2 }
1.(0 , x,  ; 1 , x ) push
2.(0 , y,  ; 1 , y ) push
3.(1 , , x ; 1 ,  ) pop
4.(1 , , y ; 1 ,  ) pop
5.(1 , x, x ; 2 ,  ) pop
6.(1 , y, y ; 2 ,  ) pop
Ejemplo 2
,x;

x, ;x x,x;

2
En (a) y (b) el AP reconoce las
secuencias, sin embargo no
ocurre lo mismo en (c). 0 1
y,;y y,y;
1.(0 , x,  ; 1 , x )
,y;
2.(0 , y,  ; 1 , y )
3.(1 , , x ; 1 ,  )
4.(1 , , y ; 1 ,  )
5.(1 , x, x ; 2 ,  )
6.(1 , y, y ; 2 ,  )

a) (0 , xx, ) b) (0 , yy, ) c) (0 , xxyy, )

1 2 1
(1 , x, x) (1 , y, y) (1 , xyy, x)
5 6 3
(2 , , ) (2 , , ) (1 , xyy, )

?
Ejemplo 2 ,x;

x, ;x x,x;
Observación
1 2
El AP es un APN 0
y,;y y,y;
,y;

1.(0 , x,  ; 1 , x )
2.(0 , y,  ; 1 , y )
(0 , xx, ) 3.(1 , , x ; 1 ,  )
1 4.(1 , , y ; 1 ,  )
Se llega a un (1 , x, x) 5.(1 , x, x ; 2 ,  )
estado de 6.(1 , y, y ; 2 ,  )
5 3
aceptación

(2 , , ) (1 , x, )

No se puede continuar
Ejemplo 2 bool reconocedor(char x[]){
strcpy(vector,x);
char temp;
int e=0; int j=0;

while(j<strlen(vector) && e!=2){

switch(e){
case 0:

Programa
if(vector[j]=='x' ){ e=1; METER('x'); }
else if(vector[j]=='y' ){ e=1; METER('y'); }
else e=3;
break;
class ARREGLO{ case 1:if(!VACIO()){
char vector[100]; temp=SACAR();
char pila[100]; if( temp=='x'){
int i,tope; if(vector[j]=='x') e=2;
public: else {e=1; j--;}
ARREGLO(char m[]){ tope=100;strcpy(pila,m); i=strlen(pila);} }
bool OCUPADO(){ else if( temp=='y'){
if (i>=tope) if(vector[j]=='y')e=2;
return true; else {e=1; j--;}
else return false; }
} else e=3;
bool VACIO(){ }else e=3;
if(i<=0) return true; break;
else return false; }
} j++;
}//fin de while
void METER(char a){ if(e==2 && (j==strlen(vector)) ) return true;
char t[2]; else return false;
t[0]=a;t[1]='\0'; }
strcat(pila,t); };
i=strlen(pila); int main(){
} char cadena[100];
char SACAR(){ char pila[100];
char a; cout<<"\n INGRESE CADENA A RECONOCER: ";cin>>cadena;
int k=strlen(pila); cout<<"\n INGRESE PILA : ";cin>>pila;
a=pila[k-1]; if(!strcmp(pila,"v")) strcpy(pila,"");
pila[k-1]='\0'; ARREGLO tira(pila);
i=strlen(pila); if(tira.reconocedor(cadena))
return a; cout<<"\n verdadero";
} else cout<<"\n falso";
getch();
}
Ejemplo 3
Construir el automata de pila a partir del siguiente lenguaje

Sea L = {a nb n : n>=0} sobre Σ= {a, b}.

1.(0 , a, Z ; 0 , AZ ) push b,A;

a, Z;AZ
2.(0 , a, A ; 0 , AA ) push ,Z;
3.(0 , b, A ; 1 ,  ) b,A; 
2
pop
4.(1 , b, A ; 1 ,  ) pop
0 1
5.(1 , , Z ; 2 ,  ) pop

a,A;AA

autopila3
Ejemplo 3
b,A;
a, Z;AZ
,Z;
b,A; 
1.(0 , a, Z ; 0 , AZ ) push
1 2
2.(0 , a, A ; 0 , AA )
3.(0 , b, A ; 1 ,  )
push
pop
0
4.(1 , b, A ; 1 ,  ) pop
5.(1 , , Z ; 2 ,  ) pop a,A;AA

RECONOCER: ab
a
cadena pila estado
1 2
ab
b Z
AZ 0 0
Ejemplo 3
b,A;
a, Z;AZ
,Z;
b,A; 
1.(0 , a, Z ; 0 , AZ ) push
1 2
2.(0 , a, A ; 0 , AA )
3.(0 , b, A ; 1 ,  )
push
pop
0
4.(1 , b, A ; 1 ,  ) pop
5.(1 , , Z ; 2 ,  ) pop a,A;AA

Cadena Pila Estado

b
 Z 1
1 2
0
Ejemplo 3
b,A;
a, Z;AZ
,Z;
b,A; 
1.(0 , a, Z ; 0 , AZ ) push
1 2
2.(0 , a, A ; 0 , AA )
3.(0 , b, A ; 1 ,  ) pop
push
0
4.(1 , b, A ; 1 ,  ) pop
5.(1 , , Z ; 2 ,  ) pop a,A;AA


cadena pila estado
1 2
  2
0
Ejemplo 3 Configuración inicial
1.(0 , a, Z ; 0 , AZ ) push
2.(0 , a, A ; 0 , AA ) push
aabb 3.(0 , b, A ; 1 ,  ) pop
4.(1 , b, A ; 1 ,  ) pop
(0 , aabb, Z)
5.(1 , , Z ; 2 ,  ) pop
Z

(0 , abb, AZ) (0 , bb, AAZ) (1 , b, AZ) (1 , , Z)

a a b b a a b b a a b b a a b b
A
A A A
0 Z 0 Z 1 Z 1 Z

(2 , ,  )
a a b b

2
Ejemplo 3
bool reconocedor(char x[]){
strcpy(vector,x);
int e=0;
int j=0;
programa char temp;
while(j<=strlen(vector)){
switch(e){
case 0:if(!VACIO()){
temp=SACAR();
class ARREGLO{
if(vector[j]=='a' && temp=='Z'){ e=0; METER('Z'); METER('A'); }
char vector[100];
else if(vector[j]=='a' && temp=='A' ){ e=0; METER('A');METER('A'); }
char pila[100];
else if(vector[j]=='b' && temp=='A' ) e=1;
int i,tope;
else e=3;
public:
}else e=3;
ARREGLO(char m[]){ tope=100;strcpy(pila,m); i=strlen(pila);}
break;
bool OCUPADO(){
case 1:if(!VACIO()){
if (i>=tope)
temp=SACAR();
return true;
if( vector[j]=='b' && temp=='A') e=1;
else return false;
else if( vector[j]=='\0' && temp=='Z' ){ e=2;METER('Z'); }
}
else e=3;
bool VACIO(){
}else e=3;
if(i<=0) return true;
break;
else return false;
}
}
j++;
}//fin de while
void METER(char a){
if(e==2 ) return true;
char t[2];
else return false;
t[0]=a;t[1]='\0';
}
strcat(pila,t);
};
i=strlen(pila);
int main(){
}
char cadena[100];
char SACAR(){
cout<<"\n INGRESE CADENA A RECONOCER: ";cin>>cadena;
char a;
ARREGLO tira("Z");
int k=strlen(pila);
if(tira.reconocedor(cadena)) cout<<"\n verdadero";
a=pila[k-1];
else cout<<"\n falso";
pila[k-1]='\0';
getch();
i=strlen(pila);
}
return a;
}
Ejemplo 4 b, B; 
a, Z; A
a, A; AA b, A; B
L = { an b 2n / n > 0 }
b, A; B
0 1
1.(0 , a, Z ; 0 , A )
2.(0 , a, A ; 0 , AA ) push
3.(0 , b, A ; 1 , B )
4.(1 , b, B ; 1 ,  ) pop

5.(1 , b, A ; 1 , B )

CORRECTOS INCORRECTOS
abb b
aabbbb ab
Ejemplo 4
a, Z; A b, B; 
Construimos un AP : b, A; B
a, A; AA
AP={ E, , p, , 0, P0, F }

E = { 0 , 1 }
b, A; B
 = { a, b } 0 1
p = { A, B }
0 E : estado inicial
Z  p : estado inicial de la pila
F = { 1 }

1.(0 , a, Z ; 0 , A )
2.(0 , a, A ; 0 , AA ) push
3.(0 , b, A ; 1 , B )
4.(1 , b, B ; 1 ,  ) pop

5.(1 , b, A ; 1 , B )
Ejemplo 4 1.(0 , a, Z ; 0 , A )
2.(0 , a, A ; 0 , AA ) push
L={ an b 2n / n>0}
3.(0 , b, A ; 1 , B )
4.(1 , b, B ; 1 ,  ) pop

a) (0 , aabbbb, Z) 5.(1 , b, A ; 1 , B )

1
(0 , abbbb, A)
2
b) (0 , abb, Z)
(0 , bbbb, AA)
1 a, Z; A b, B; 
3 (0 , bb, A) a, A; AA b, A; B
(1 , bbb, BA) 3
4 (1 , b, B)
(1 , bb, A) 4 b, A; B
5 (1 , , )
0 1
(1 , b, B)
4
(1 , , )
Ejemplo 4 1.(0 , a, Z ; 0 , A )
2.(0 , a, A ; 0 , AA ) push
L={ an b 2n / n>0}
3.(0 , b, A ; 1 , B )
4.(1 , b, B ; 1 ,  ) pop

5.(1 , b, A ; 1 , B )
(0 , ab, Z)
1
(0 , b, A)
3
(1 , , B)

Se observa que el
reconocimiento se da si la
pila queda vacía
Ejemplo 4
bool reconocedor(char x[]){
strcpy(vector,x);
int e=0;
int j=0;
char temp;
while(j<strlen(vector)){
switch(e){
case 0:if(!VACIO()){
temp=SACAR();
if(vector[j]=='a'){
if(temp=='Z' ){ e=0; METER('A'); }
else if(temp=='A' ){ e=0; METER('A'); METER('A'); }
class ARREGLO{
else e=3;
char vector[100];
else if(vector[j]=='b' && temp=='A' ) { e=1; METER('B'); }
char pila[100];
else e=3;
int i,tope;
}
public:
else e=3;
ARREGLO(char m[]){ tope=100;strcpy(pila,m); i=strlen(pila);}
break;
bool OCUPADO(){
case 1:if(!VACIO()){
if (i>=tope)
temp=SACAR();
return true;
if(vector[j]=='b'){
else return false;
if(temp=='B' ) e=1;
}
else if(temp=='A' ){ e=1; METER('B'); }
bool VACIO(){
else e=3;
if(i<=0) return true;
}
else return false;
else e=3;
}
}else e=3;
break;
void METER(char a){
}
char t[2];
j++;
t[0]=a;t[1]='\0';
}//fin de while
strcat(pila,t);
if((e==1 ) && VACIO()) return true;
i=strlen(pila);
else return false;
}
}
char SACAR(){
};
char a;
int main(){
int k=strlen(pila);
char cadena[100];
a=pila[k-1];
cout<<"\n INGRESE CADENA A RECONOCER: ";cin>>cadena;
pila[k-1]='\0';
ARREGLO tira("Z");
i=strlen(pila);
if(tira.reconocedor(cadena)) cout<<"\n verdadero";
return a;
else cout<<"\n falso";
}
getch();
}
AP DETERMINISTA
AP={ E, , p, , 0, P0, F }
E : conjunto finito de estados
 : alfabeto del sistema
p : alfabeto de la pila
 : función de transición
0 E : estado inicial
P0  p : estado inicial de la pila
F E : conjunto de estados finales

• (q, a, x) tiene como maximo un elemento para

cualquier q en E, a   o a =  y x  p

• Si (q, a, x) ≠ ∅ para algún a   entonces (q, , x) = ∅

Ejemplo 5

L = { am bp c p+m / m, p > 0 }  {a2i bi / i > 0}

CORRECTOS INCORRECTOS
abcc abc
aaabbccc aaabb
aab
aaaabb
Ejemplo 5
1.(0 , a, Z ; 1 , AZ )
2.(0 , a, Z ; 5 , AZ )
3.(1 , a, A ; 1 , AA )
a, A ; AA b, B ; BB c, B ;  c, A ; 
4.(1 , b, A ; 2 , BA )
5.(2 , b, B ; 2 , BB )
b, A ; BA c, B ;  c, A ; 
6.(2 , c, B ; 3 ,  ) 1 2 3 4
7.(3 , c, B ; 3 ,  )
8.(3 , c, A ; 4 ,  ) a, Z ; AZ
, Z ; Z
9.(4 , c, A ; 4 ,  )
0
10.(4 , , Z ; 8 , Z ) a, A ; A
, Z ; Z 8
11.(5 , a, A ; 6 , A ) a, Z ; AZ b, A ; 
5 6 7
12.(6 , a, A ; 5 , AA )
a, A ; AA
13.(6 , b, A ; 7 ,  )
14.(7 , b, A ; 7 ,  )
15.(7 , , Z ; 8 , Z ) b, A ; 
NO DETERMINISTA
a, A ; AA b, B ; BB c, B ;  c, A ; 

b, A ; BA c, B ;  c, A ; 
1 2 3 4

a, Z ; AZ
, Z ; Z
0
a, A ; A

a, Z ; AZ , Z ; Z 8
b, A ; 
5 6 7
a, A ; AA

b, A ; 

(0 , a, Z )={ (1 , AZ ), (5 , AZ ) }

Ejercicios

Escriba el autómata de pila y su programa para

los siguientes lenguajes

1. L={ancbm | n,m>0}.
2. L={anbm | n  m, n,m>0}.
3. L={anbm | n  m, n,m≥0}.
4. L = {aibjck | i, j>0 y k=i+j}
5. L= {aib ck | i, k 1 y i  k}
El programa puede ser en java o C++
EJERCICIO 4
Escriba el autómata de pila para el
siguiente lenguaje y luego prográmelo abcc

(q1, abcc, Z)
L = {ambncm+n | n, m>0 } (q1, bcc, AZ)
(q2, cc, AAZ)
(q3, c, AZ)
1. (q1, a , A: q1, AA)
(q3, &, Z)
2. (q1, a , Z: q1, AZ)
(q4, &, &)
3. (q1, b , A: q2, AA )
4. (q2, b , A: q2, AA)
5. (q2, c , A: q3, & )
6. (q3, c , A: q3, &)
7. (q3, &, Z: q4, &)
EJERCICIO

Escriba el autómata de pila para el

siguiente lenguaje y luego prográmelo

L = {ambncm-n | m, n>0 y m>n}

LABORATORIO
Escribir un autómata con pila para reconocer cabeceras for (f) como se muestra
en el ejemplo. Prográmelo en C++ o java

ejemplos
f(j=0; j<8; j+)
f(j=7, k=p; (7<k) & (k>0); j+, k-)
f(p=3; m & (p<7); p+)
f(;;)
f(k=0;;)

Observaciones:
• Todas las palabras son de un carácter(constantes e identificadores)
• Solo se consideran los siguientes operadores, relacional(>, <), asignación(=),
incremento o decremento (+,-), delimitador( ; , ), ( ) , op lógico (&), separador(,)
• El for se compone de tres partes, muchas inicializaciones e incrementos y la parte de
condición tener expresiones distintas.
• En su envió debe estar el programa y además la explicación de como lo ha hecho,
además de toda la información necesaria para ingresar los datos de entrada (ponga
ejemplos de como ingresar los datos a su autómata con pila)
• Enviar al correo institucional (cruizdelacruzm@unmsm.edu.pe)
• Trabaje en grupo de 4 alumnos como máximo o individual