Automate à pile - Définition

Source: Wikipédia sous licence CC-BY-SA 3.0.
La liste des auteurs de cet article est disponible ici.

Exemples

Reconnaissance du langage \{a^kb^k | k \ge 1 \}

On peut utiliser l'automate M = (\{q_0, q_1, q_2, q_3\}, \{a, b\}, \{A,\underline{A}\}, \delta, \omega, q_0, \{q_0, q_3\} ),

où les transitions sont définies par :

(1) \delta(q_0, a, \omega) = \{(q_1, \underline{A})\}

(2) \delta(q_1, a, \omega) = \{(q_1, A)\}\underline{}

(3) \delta(q_1, b, A) = \{(q_2, \omega)\}\underline{}

(4) \delta(q_1, b, \underline{A}) = \{(q_3, \omega)\}

(5) \delta(q_2, b, A) = \{(q_2, \omega)\}\underline{}

(6) \delta(q_2, b, \underline{A}) = \{(q_3, \omega)\}

(7) \delta(q, \theta, \rho) = \empty pour les autres valeurs de (q, \theta, \rho)\underline{}

Par exemple, dans l'état q_1\underline{} , si on lit un b\underline{} et que l'on dépile un A\underline{} , on passe dans l'état q_2\underline{} sans rien empiler.

Automateapile.png

On commence par lire le premier caractère : Si le mot est vide on a fini et le mot est accepté car q0 est un état final. Si c'est un a, on empile \underline{A} (1) (il marque le fond de la pile), et on passe à l'état q1. Si c'est un b, le mot est rejeté (7).

Ensuite dans l'état q1, à chaque a on empile A (2). Si on a un b, deux possibilités : - Si on n'a empilé qu'un seul \underline{A} on passe à l'état q3 en dépilant le \underline{A} (4). - Si on a empilé un ou plus A, on passe à l'état q2 en dépilant un A (3).

Dans l'état q2, si on a un b, soit on dépile un A et on reste dans cet état (5), soit on dépile un \underline{A} (fond de la pile) et on passe dans l'état q3 (6). Si on lit un a, on désactive l'automate et le mot est rejeté (7).

Dans l'état q3, si le mot est fini on l'accepte car q_3\in T , si non on le rejette (7).

Implémentation d'un automate à pile

En langage C :

  1.       #include       
  2.       #include       
  3.              
  4.       #define POP	-1      
  5.       #define ACCEPT	-2      
  6.       #define ERROR	-3      
  7.              
  8.       #define ALPHABET 3	/* Grandeur*/      
  9.              
  10.       /*      
  11.       	Push-down automation)      
  12.              
  13.       	Symbol   | (       | )	    | \0      
  14.       	---------+---------+--------+-----------      
  15.       	State 0  | PUSH 1  | ERROR  | ACCEPT      
  16.       	State 1  | PUSH 1  | POP    | ERROR      
  17.       */      
  18.              
  19.       int states[2][ALPHABET*2] =      
  20.       {      
  21.       	{      
  22.       		'(',	1 /* PUSH 1 */,      
  23.       		')',	ERROR,      
  24.       		'\0',	ACCEPT      
  25.       	},      
  26.       	{      
  27.       		'(',	1 /* PUSH 1 */,      
  28.       		')',	POP,      
  29.       		'\0',	ERROR      
  30.       	}      
  31.       };      
  32.              
  33.              
  34.       int main( int argc, char** argv )      
  35.       {      
  36.       	int	stack[100]	= { 0 };      
  37.       	int	i		= 0;      
  38.       	int	action		= 0;      
  39.       	int*	tos		= stack;      
  40.       	char	s		[80+1];      
  41.       	char*	p		= s;      
  42.              
  43.       	/* Chaine de donnée */      
  44.       	printf("Entrez l'expression: ");      
  45.       	gets( &s );      
  46.              
  47.       	/*Pile poussée*/      
  48.       	*(tos++) = 0;      
  49.              
  50.       	/* Sortie */      
  51.       	do      
  52.       	{      
  53.       		/* Boucle*/      
  54.       		action = ERROR;      
  55.       		for( i = 0; i < ALPHABET; i++ )      
  56.       		{			      
  57.       			if( states[*(tos-1)][i*2] == *p )      
  58.       			{      
  59.       				action = states[*(tos-1)][i*2+1];      
  60.       				break;      
  61.       			}      
  62.       		}      
  63.              
  64.       		/* Actions*/      
  65.       		if( action == ERROR )      
  66.       		{      
  67.       			printf("Erreur inattendue à la position %d", p-s);      
  68.       			break;      
  69.       		}      
  70.       		else if( action == ACCEPT )      
  71.       			printf("Sortie acceptée!");      
  72.       		else if( action == POP )      
  73.       			tos--;      
  74.       		else      
  75.       			*(tos++) = action;      
  76.              
  77.       		/* Données supplémentaires... */      
  78.       		p++;      
  79.       	}      
  80.       	while( action != ACCEPT );      
  81.              
  82.       	getchar();      
  83.       	return 0;      
  84.       }      
Page générée en 0.079 seconde(s) - site hébergé chez Contabo
Ce site fait l'objet d'une déclaration à la CNIL sous le numéro de dossier 1037632
A propos - Informations légales
Version anglaise | Version allemande | Version espagnole | Version portugaise