Implémentation des automates

F. Barthélemy
19 octobre 2010

Introduction
On va se donner comme problème : écrire un programme qui teste si une chaı̂ne donnée
appartient au langage d’un automate fini déterministe donné. Cette chaı̂ne sera donnée sous forme
d’une chaı̂ne de caractères.

1 Automate codé dans les instructions du programme

C’est une démarche qu’on peut suivre lorsqu’on a un petit automate immuable. Les transi-
tions sont transcrites par des branchements conditionnels.
a
3
b c
a
1 2 a 4
Exemple :
p u b l i c c l a s s EncodeAutoCode {
s t a t i c boolean automate ( S t r i n g s ){
int e t a t = 1;
f o r ( i n t i = 0 ; i <s . l e n g t h ( ) ; i ++){
S ystem . o u t . p r i n t l n ( ”−−−” + e t a t + ” ” + s . c h a r A t ( i ) ) ;
switch ( s . charAt ( i ) ) {
case ’ a ’ :
i f ( e t a t ==1 | | e t a t ==2 | | e t a t ==4){
e t a t = 2;
break ;
} else
return f a l s e ;
case ’b ’ :
i f ( e t a t ==2){
e t a t =3;

1
 break ;
}
else
return f a l s e ;
case ’ c ’ :
i f ( e t a t ==3){
e t a t = 4;
break ;
} else
return f a l s e ;
default :
S ystem . o u t . p r i n t l n ( ” C a r a c t è r e h o r s a l p h a b e t : ” + s . c h a r A t ( i ) ) ;
return f a l s e ;
}
}
S ystem . o u t . p r i n t l n ( ”−−−” + e t a t ) ;
return ( e t a t = = 2 ) | | ( e t a t ==4);
}
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
boolean r e s ;
i f ( a r g s . l e n g t h ==0)
S ystem . o u t . p r i n t l n ( ” c h a ı̂ n e s à t e s t e r a t t e n d u e s s u r l a l i g n e de commande
f o r ( i n t i = 0 ; i < a r g s . l e n g t h ; i ++){
S ystem . o u t . p r i n t l n ( ” C h aı̂ n e t e s t é e : ” + a r g s [ i ] ) ;
r es = automate ( args [ i ] ) ;
S ystem . o u t . p r i n t l n ( ” R é s u l t a t : ” + r e s ) ;
}
}
}

Exemple d’exécution :

> java EncodeAutoCode aaa aab aabc aaabcabcabc adz

Chaı̂ne testée: aaa
---1 a
---2 a
---2 a
---2
Résultat: true
Chaı̂ne testée: aab
---1 a
---2 a
---2 b
---3
Résultat: false

2
Chaı̂ne testée: aabc
---1 a
---2 a
---2 b
---3 c
---4
Résultat: true
Chaı̂ne testée: aaabcabcabc
---1 a
---2 a
---2 a
---2 b
---3 c
---4 a
---2 b
---3 c
---4 a
---2 b
---3 c
---4
Résultat: true
Chaı̂ne testée: adz
---1 a
---2 d
Caractère hors alphabet: d
Résultat: false

2 Implementation d’un automate comme une donnée

La représentation de l’automate n’est pas dans les instructions mais dans des variables. Il faut
alors un programme pour interpréter ces données et produire une exécution. Ce programme est
le même pour tous les automates codé de la même façon.
Une représentation classique : au moyen de tableaux. Un tableau à deux dimensions pour les
transitions et un tableau de booléens pour le caractère final ou non des états.
Pour le même automate qu’à la section précédente, les deux tableaux en question sont :
état de départ a b c
1 2
2 2 3
3 4
4 2
et

3
 etat 1 2 3 4
final false true false true
Pour une représentation en java, il faut adapter la représentation parce que les tableaux sont
indicés par des entiers à partir de 0. Il faut un encodage des caractères de l’alphabet et par ailleurs
retrancher 1 au numéro de l’état. De plus, on va remplir les cases vides avec -1.
p u b l i c c l a s s EncodeAutoSDD {
s t a t i c i n t c h a r T o I n t ( char c ) {
switch ( c ){
case ’ a ’ : return 0;
case ’b ’ : return 1;
case ’ c ’ : return 2;
d e f a u l t : r e t u r n −1;
}
}
s t a t i c boolean automate ( S t r i n g s , i n t [ ] [ ] t r , boolean [ ] e f ){
int e t a t = 0;
f o r ( i n t i = 0 ; i <s . l e n g t h ( ) ; i ++){
S ystem . o u t . p r i n t l n ( ”−−−” + ( e t a t +1) + ” ” + s . c h a r A t ( i ) ) ;
i n t l e c h a r = charToInt ( s . charAt ( i ) ) ;
i f ( l e c h a r == −1){
S ystem . o u t . p r i n t l n ( ” C a r a c t è r e h o r s a l p h a b e t : ” + s . c h a r A t ( i ) ) ;
return f a l s e ;
}
e t a t = t r [ e t a t ] [ charToInt ( s . charAt ( i ) ) ] ;
i f ( e t a t ==−1)
return f a l s e ;
}
S ystem . o u t . p r i n t l n ( ”−−−” + ( e t a t + 1 ) ) ;
return ef [ e t a t ] ;
}
p u b l i c s t a t i c v o i d main ( S t r i n g [ ] a r g s ) {
i n t [ ] [ ] t r a n s i t i o n s = {{1 , −1 , −1} ,{1 ,2 , −1} ,{ −1 , −1 ,3} ,{1 , −1 , −1}};
b o o l e a n [ ] e t a t f i n a l = { f a l s e , tru e , f a l s e , t r u e } ;
boolean r e s ;
i f ( a r g s . l e n g t h ==0)
S ystem . o u t . p r i n t l n ( ” c h a ı̂ n e s à t e s t e r a t t e n d u e s s u r l a l i g n e de commande
f o r ( i n t i = 0 ; i < a r g s . l e n g t h ; i ++){
S ystem . o u t . p r i n t l n ( ” C h aı̂ n e t e s t é e : ” + a r g s [ i ] ) ;
r es = automate ( args [ i ] , t r a n s i t i o n s , e t a t f i n a l ) ;
S ystem . o u t . p r i n t l n ( ” R é s u l t a t : ”+ r e s ) ;
}
}
}

Et voici un exemple d’exécution.

4
> java EncodeAutoSDD aabc aaabcabcabc adz
Chaı̂ne testée: aabc
---1 a
---2 a
---2 b
---3 c
---4
Résultat: true
Chaı̂ne testée: aaabcabcabc
---1 a
---2 a
---2 a
---2 b
---3 c
---4 a
---2 b
---3 c
---4 a
---2 b
---3 c
---4
Résultat: true
Chaı̂ne testée: adz
---1 a
---2 d
Caractère hors alphabet: d
Résultat: false