Update

docs/tp/3_tp3/3_tp3.mdx

@@ -5,6 +5,11 @@ cor: true
 title: "TP 3 : Algorithme de Berry-Sethi"
 ---
 
+import Solution from '@site/src/components/Solution';
+import TP from '!!raw-loader!./tp3.ml';
+
+<Solution file={TP} lang='ocaml' show={frontMatter.cor} />
+
 ## Fonctions utilitaires
 
 On utilisera le type suivant d'expression régulière : 
@@ -72,12 +77,19 @@ produit [1;2] [3;4];;
 - : (int * int) list = [(1, 3); (1, 4); (2, 3); (2, 4)]
 ```
 9. Écrire une fonction `f : 'a regexp -> ('a * 'a) list` renvoyant l'ensemble $F(L)$ d'une expression régulière, sous forme de liste de couples dans un ordre quelconque.
+```ocaml
+f (Concat (Concat(L 1, L 3), L 2));;
+- : (int * int) list = [(1, 3); (3, 2)]
+````
 
 ## Linéarisation d'une expression régulière
 
 10. Écrire une fonction `n_lettres : 'a regexp -> int` renvoyant le nombre de lettres d'une expression régulière. Par exemple, `n_lettres (Union (Concat (L 'a', L 'b'), Etoile (L 'a')))` doit renvoyer `3`.  
-11. Écrire une fonction `lineariser : 'a regexp -> int regexp` renvoyant la linéarisation d'une expression régulière, où les lettres sont numérotées par des entiers croissants à partir de $1$.  
-Par exemple, `lineariser (Union (Concat (L 'a', L 'b'), Etoile (L 'a')))` doit renvoyer `Union (Concat (L 1, L 2), Etoile (L 3)))`.
+11. Écrire une fonction `lineariser : 'a regexp -> ('a * int) regexp` renvoyant la linéarisation d'une expression régulière, où la $i$ème occurrence d'une lettre $a$ est remplacée par $(a, i)$.  
+```ocaml
+lineariser (Union (Concat (L 'a', L 'b'), Etoile (L 'a')));;
+- : (char * int) regexp = Union (Concat (L ('a', 1), L ('b', 2)), Etoile (L ('a', 3)))
+```
 
 ## Automate de Glushkov
 
@@ -92,4 +104,4 @@ type automate = {
 Ainsi, si `a` est un automate, `a.delta.(i).(j)` est la liste des états atteignables depuis l'état `i` avec la lettre `j`. `a.finaux.(i)` est vrai si l'état `i` est final.
 
 12. Écrire une fonction `glushkov : 'a regexp -> automate` renvoyant l'automate de Glushkov d'une expression régulière.  
-13. Définir une expression régulière dont le langage est l'ensemble des mots sur $\{0, 1\}$ ayant un nombre pair de $0$ et vérifier l'automate de Glushov obtenu.
+13. Définir une expression régulière dont le langage est l'ensemble des mots sur $\{a, b\}$ ayant un nombre pair de $a$ et vérifier l'automate de Glushov obtenu en le dessinant à la main.

docs/tp/3_tp3/tp3.ml

@@ -97,3 +97,42 @@ let rec n_lettres e = match e with
     | Etoile e1 -> n_lettres e1;;
 
 (* 11 *)
+(* attention au fait que dans Union(aux e1, aux e2) appelle d'abord aux e2, puis aux e1 *)
+let lineariser e =
+    let r = ref 0 in
+    let rec aux e = match e with
+        | Vide -> Vide
+        | Epsilon -> Epsilon
+        | L a -> incr r; L (a, !r)
+        | Union (e1, e2) -> let e1' = aux e1 in
+                            let e2' = aux e2 in
+                            Union (e1', e2')
+        | Concat (e1, e2) -> let e1' = aux e1 in
+                             let e2' = aux e2 in
+                             Concat (e1', e2')
+        | Etoile e1 -> Etoile (aux e1) in
+    aux e;;
+lineariser (Union (Concat (L 'a', L 'b'), Etoile (L 'a')));;
+
+type 'a automate = { 
+    delta : 'a list array array;
+    finaux : bool array;
+}
+(* 12 *)
+let glushkov e =
+    let e' = lineariser e in
+    let n = n_lettres e' in
+
+    let delta = Array.make_matrix (n + 1) (n + 1) [] in
+    (* ajoute une transition de i vers j *)
+    let add i j k = delta.(i).(j) <- k::delta.(i).(j) in
+    List.iter (fun (a, i) -> add 0 i a) (p e');
+    List.iter (fun ((a, i), (b, j)) -> add i j b) (f e');
+
+    let finaux = Array.make (n + 1) false in
+    List.iter (fun (a, i) -> finaux.(i) <- true) (s e');
+    { delta = delta; finaux = finaux };;
+
+(* 13 *)
+let e = Etoile (Union(L 'b', Concat(L 'a', Concat(Etoile (L 'b'), L 'a'))));;
+glushkov e