PROJET TP THL

Année Universitaire : 2021/2022

SOUS LA SUPERVISATION DE : Dr R.BAGHLI
Présenté par :
• BARÇA Ahmed Fateh
• ZAHAF Boualam Nadjib
• RABIAI Mehdi Ayoub

Université Benyoucef Benkhedda, Faculté des science, Département Informatique, L2, groupes 1 et 3

1
INTRODUCTION :
En Théorie Des Langages, on est amené à manipuler des mots faisant parties de langages
générés par des grammaires. Dans ce projet, on va voir certaines des opérations que l’on peut
faire sur les mots. On va voir aussi comment lister tous les mots d’un langage fini et vérifier, à
l’aide d’une grammaire, si un mot est syntaxiquement correct et s’il fait bien partie du langage
que cette grammaire génère.

DEVELOPPEMENT :

PARTIE 01 :
Pour réaliser les opérations mot miroir d’un mot et puissances d’un mot, on a créé une
classe “Mot” qui regroupe les deux méthodes “miroir” et “puis” (ainsi qu’une autre méthode
qui nous sera utile dans la partie 03). Les deux premières méthodes seront appelées dans une
autre classe “TestPart1” afin de les tester avec des valeurs rentées au clavier.

Pour ce qui est de la méthode “miroir” : soit un mot composé de lettres indexées dans
l’ordre, 0,1,2,3,…,n-1n,n. La méthode “miroir” retourne les mêmes lettres que ceux du mot
rentré, mais dans l’ordre inverse, c’est à dire n,n-1,…,3,2,1,0.
On obtiendra :
Suite des indexe lettres de mot -------------------------> Suite des indexe lettres de mot.miroir()

George -------------------------> egroeG

1 2 3456 6543 2 1

Ensuite, la méthode “puis” : la puissance d’un mot ω donné est la concaténation de ce mot
n fois avec lui-même.

ω0=ε ω1= ω ωn= ω.ω.ω......ω (n fois)

On prend alors dans la méthode “puis” une chaine de caracteres vide à laquelle on ajoute
(grâce une boucle for) n fois le mot donné. Si n est égale à 0 on obtient une chaine vide, si
non, on obtient la concaténation de ce mot n fois comme demandé.

2
PARTIE 02 :
Afin de réaliser cette partie, on a créé une formule qui nous donne le nombre exact de mot
qu’on peut réaliser avec n lettres. Cette formule est la suivante :

2 (n-3) *((n-3)+1)

Tel que 2 (n-3) est la taille d’un cycle et que (n-3)+1 est le nombre de cycles. Pour ce qui est
du 2, c’est car on a deux lettres possibles, le a et le b, et donc on veut traiter ces combinaisons
comme des nombres binaires (les 0 sont des a et les 1 sont des b).

Tout est plus claire avec un exemple, et donc prenons l’exemple de n=5 notre formule
donnera alors : 2 2 * 3 =12
2

aa aa aa
ab ab ab
ba ba ba
bb bb bb

3
Ce qu’il nous reste à faire c’est de placer les “abb” au bon endroit

abbaa aabba aaabb

abbab aabbb ababb
abbba babba baabb
abbbb babbb bbabb
Cycle 1: pos 0 Cycle 2: pos 1 Cycle 3: pos 2
Le seul cas spécial reste si n est inférieur à trois, où dans ce cas, il est impossible de créer
un mot.

Toutes ces étapes ont été réalisées dans la classe “TestPart2” uniquement.

PARTIE 03 :
On revient à la classe “Mot” où se situe la méthode “syntaxe“ qui vérifie si un mot donné
est syntaxiquement correct et donc s'il appartient au langage généré par la grammaire donnée

3
(car le mot à vérifier est déjà lexicalement correct). Pour ce faire, on s’assure juste que le
nombre d’occurrences des “a” qui arrivent avant le premier “b” est supérieur ou égale au
double du nombre total des occurrences de “b”.

Par exemple : aaaaaaabbaabaaa

1 2 3456 7 12 3
Nous avons alors 7 ≥ 2*3, donc ce mot appartient au langage généré par la grammaire.

Cela est possible à vérifier grâce à une boucle while (munie d’un compteur) qui s’arrête au
premier b qu’elle trouve dans la chaine de caractères donnée. Puis, une autre boucle qui
compte le nombre de b. On compare par la suite les deux résultats et on voit si le mot est bien
généré par la grammaire.

La méthode “syntaxe” est par la suite appelée par la classe “TestPart3” afin de pouvoir la
tester avec des valeurs qu’on saisira au clavier.

CONCLUSION :
En conclusion, en théorie des langages, on traite des mots qu’on peut manipuler et sur
lesquels on peut faire des opérations. Ces mots appartiennent à un langage (qui peut être fini
ou non) généré par une grammaire, qui à son tour détermine si un mot fait (ou non) partie de
ce langage (lexicalement et syntaxiquement).

A la fin de ce TP on est capable de créer des algorithmes qui font certaines des opérations
possibles sur un mot, tel que le mot miroir et la puissance d’un mot, lister tous les mots d’un
langage fini et vérifier si un mot est syntaxiquement correct et s'il appartient au langage
générer par une grammaire.

FIN.