grand dico

This reverts commit ed1ad0566f, reversing
changes made to 6ee909914d.

.gitignore

@@ -1,3 +1,5 @@
 __pycache__/
 test*.*
-*.py
+*.py
+dico2.csv
+wiktionaryXfr2010.7z

Grille.php

@@ -2,16 +2,33 @@
 include_once "dico.php";
 
 
-class Grille implements ArrayAccess {
+$randmax = mt_getrandmax() + 1;
+function gaussienne($moyenne = 0, $ecartType = 1.0): float {
+    global $randmax;
+    
+    $u = 0;
+    $v = 0;
+
+    $u = (mt_rand() + 1) / $randmax;
+    $v = (mt_rand() + 1) / $randmax;
+
+    $z = sqrt(-2.0 * log($u)) * cos(2.0 * M_PI * $v);
+    return $z * $ecartType + $moyenne;
+}
+
+
+class Grille implements ArrayAccess
+{
     public $grille;
     public $hauteur;
     public $largeur;
-    private $lettres_suivantes;
+    public $dico;
     private $positions;
     private $nb_positions;
     public $lignes = [];
     public $colonnes = [];
     public $valide = false;
+    private $id;
 
     public function __construct($hauteur, $largeur)
     {
@@ -26,13 +43,13 @@ class Grille implements ArrayAccess {
         }
         $this->nb_positions = count($this->positions);
 
-        $this->lettres_suivantes = tries(max($hauteur, $largeur));
+        $this->dico = mots_espaces(max($hauteur, $largeur));
     }
 
     public function get_ligne($y, $largeur)
     {
         $ligne = "";
-        for ($x = 0; $x < $largeur; $x++) 
+        for ($x = 0; $x < $largeur; $x++)
             $ligne .= $this->grille[$y][$x];
         return $ligne;
     }
@@ -45,33 +62,51 @@ class Grille implements ArrayAccess {
         return $colonne;
     }
 
-    public function gen_grilles($i = 0, $lettres_suivantes_ligne = NULL)
+    public function gen_grilles($i = 0, $lettres_ligne = NULL)
     {
         [$x, $y] = $this->positions[$i];
 
+        // Recherche de la prochaine lettre possible sur la case courante
+        // en ligne
         if ($x == 0) {
-            $lettres_suivantes_ligne = $this->lettres_suivantes[$this->largeur];
+            $lettres_ligne = $this->dico[$this->largeur];
         }
 
-        $lettres_suivantes_colonne = $this->lettres_suivantes[$this->hauteur];
-        for ($y2 = 0; $y2 < $y; $y2++)
-            $lettres_suivantes_colonne = $lettres_suivantes_colonne->noeud[$this->grille[$y2][$x]];
-        $lettres_communes = array_intersect(
-            array_keys($lettres_suivantes_ligne->noeud),
-            array_keys($lettres_suivantes_colonne->noeud)
+        // en colonne
+        $lettres_colonne = $this->dico[$this->hauteur];
+        for ($y2 = 0; $y2 < $y; $y2++) {
+            $lettres_colonne = $lettres_colonne->branches[$this->grille[$y2][$x]];
+        }
+        $lettres_communes = array_intersect_key(
+            $lettres_ligne->branches,
+            $lettres_colonne->branches
         );
-        usort($lettres_communes, function ($a, $b) {
-            return mt_rand(-1, 1);
+        foreach ($lettres_communes as $lettre => $_) {
+            $lettres_communes[$lettre] = count($lettres_ligne->branches[$lettre]) * count($lettres_colonne->branches[$lettre]) * gaussienne(1, 5);
+        }
+        uksort($lettres_communes, function($a, $b) use ($lettres_communes) {
+            return $lettres_communes[$b] <=> $lettres_communes[$a];
         });
+        $lettres_communes = array_slice($lettres_communes, 0, 3);
 
-        foreach ($lettres_communes as $lettre) {
+        foreach ($lettres_communes as $lettre => $_) {
             $this->grille[$y][$x] = $lettre;
 
+            // Omission des lettres isolées
+            if ($lettre == " "
+                && ($y - 2 < 0 || $this->grille[$y - 2][$x] == " ")
+                && ($y - 1 < 0 || $x - 1 < 0 || $this->grille[$y - 1][$x - 1] == " ")
+                && ($y - 1 < 0 || $x + 1 >= $this->largeur || $this->grille[$y - 1][$x + 1] == " ")
+            ) {
+                continue;
+            }
+
+            // Omission des doublons
             $mots = [];
             if ($x == $this->largeur - 1) $mots = explode(" ", $this->get_ligne($y, $this->largeur));
             else if ($lettre == " ") $mots = explode(" ", $this->get_ligne($y, $x));
             else $mots = [];
-            $this->lignes[$y] = array_filter($mots, function($mot) {
+            $this->lignes[$y] = array_filter($mots, function ($mot) {
                 return strlen($mot) >= 2;
             });
             if (count($this->lignes[$y])) {
@@ -92,24 +127,23 @@ class Grille implements ArrayAccess {
             }
 
             if ($i < $this->nb_positions - 1) {
-                yield from $this->gen_grilles($i + 1, $lettres_suivantes_ligne->noeud[$lettre]);
+                yield from $this->gen_grilles($i + 1, $lettres_ligne->branches[$lettre]);
             } else {
                 yield $this;
             }
         }
     }
 
-    public function genere() {
-        session_regenerate_id();
-        $id = session_id();
+    public function genere($id)
+    {
         mt_srand(crc32($id));
 
         $grilles = $this->gen_grilles();
         $grilles->current();
 
         if ($grilles->valid()) {
-            $this->save();
-            return $id;
+            $this->save($id);
+            return true;
         } else {
             return false;
         }
@@ -123,7 +157,9 @@ class Grille implements ArrayAccess {
         return hash('sha256', $string);
     }
 
-    public function save() {
+    public function save($id)
+    {
+        session_id($id);
         session_start(["use_cookies" => false]);
 
         $_SESSION["$this->largeur,$this->hauteur"] = implode(
@@ -137,7 +173,8 @@ class Grille implements ArrayAccess {
         );
     }
 
-    public function load($id) {
+    public function load($id)
+    {
         session_id($id);
         session_start(["use_cookies" => false]);
 
@@ -146,21 +183,21 @@ class Grille implements ArrayAccess {
         }
 
         foreach (str_split($_SESSION["$this->largeur,$this->hauteur"], $this->largeur) as $y => $ligne) {
-            foreach(str_split($ligne) as $x => $lettre) {
+            foreach (str_split($ligne) as $x => $lettre) {
                 $this->grille[$y][$x] = $lettre;
             }
         }
-        
+
         for ($y = 0; $y < $this->hauteur; $y++) {
             $mots = explode(" ", $this->get_ligne($y, $this->largeur));
-            $this->lignes[$y] = array_filter($mots, function($mot) {
+            $this->lignes[$y] = array_filter($mots, function ($mot) {
                 return strlen($mot) >= 2;
             });
         }
-        
+
         for ($x = 0; $x < $this->largeur; $x++) {
             $mots = explode(" ", $this->get_colonne($x, $this->hauteur));
-            $this->colonnes[$x] = array_filter($mots, function($mot) {
+            $this->colonnes[$x] = array_filter($mots, function ($mot) {
                 return strlen($mot) >= 2;
             });
         }
@@ -169,19 +206,23 @@ class Grille implements ArrayAccess {
     }
 
 
-    public function offsetExists(mixed $offset): bool {
+    public function offsetExists(mixed $offset): bool
+    {
         return isset($this->grille[$offset]);
     }
 
-    public function offsetGet(mixed $offset): mixed {
+    public function offsetGet(mixed $offset): mixed
+    {
         return $this->grille[$offset];
     }
 
-    public function offsetSet(mixed $offset, mixed $value): void {
+    public function offsetSet(mixed $offset, mixed $value): void
+    {
         $this->grille[$offset] = $value;
     }
 
-    public function offsetUnset(mixed $offset): void {
+    public function offsetUnset(mixed $offset): void
+    {
         unset($this->grille[$offset]);
     }
 }

Trie.php

@@ -1,70 +1,95 @@
 <?php
 
 
-class Trie implements ArrayAccess, IteratorAggregate //, Countable //, Iterator
-{
-    public array $noeud = [];
+class Trie implements ArrayAccess, IteratorAggregate, Countable {
+    public array $branches = [];
+    private $nb_branches = 0;
 
-    public function offsetSet($cles, $valeur): void {
-        if (!count($cles)) {
-            throw new \OutOfBoundsException("Liste de clés vide.");
-        }
-        $cle = array_shift($cles);
-        if (!isset($this->noeud[$cle])) $this->noeud[$cle] = new Trie();
-        if (count($cles)) {
-            $this->noeud[$cle]->offsetSet($cles, $valeur);
+    public function arraySet($cles, $valeur) {
+        $this->nb_branches++;
+        $cle = $cles[0];
+        $cles = array_slice($cles, 1);
+        if ($cles == []) {
+            $this->branches[$cle] = $valeur;
         } else {
-            $this->noeud[$cle] = $valeur;
+            if (!isset($this->branches[$cle])) $this->branches[$cle] = new Trie();
+            $this->branches[$cle]->arraySet($cles, $valeur);
+        }
+    }
+
+    public function arrayExists($cles) {
+        $cle = $cles[0];
+        $cles = array_slice($cles, 1);
+        if ($cles == []) {
+            return isset($this->branches[$cle]);
+        } else {
+            return isset($this->branches[$cle]) && $this->branches[$cle]->arrayExists($cles);
+        }
+    }
+
+    public function &arrayGet($cles) {
+        $cle = $cles[0];
+        $cles = array_slice($cles, 1);
+        if ($cles == []) {
+            return $this->branches[$cle];
+        } else {
+            return $this->branches[$cle]->arrayGet($cles);
+        }
+    }
+
+    public function arrayUnset($cles) {
+        $cle = $cles[0];
+        $cles = array_slice($cles, 1);
+        if ($cles == []) {
+            unset($this->branches[$cle]);
+            $this->nb_branches--;
+        } else {
+            $this->branches[$cle]->arrayUnset($cles);
+            $this->nb_branches--;
+            if (count($this->branches[$cle]) == 0) {
+                unset($this->branches[$cle]);
+            }
+        }
+    }
+
+    public function arrayIterator() {
+        foreach ($this->branches as $cle => $branche) {
+            if ($branche instanceof Trie) {
+                foreach($branche->arrayIterator() as $sous_cles => $feuille) {
+                    yield array_merge([$cle], $sous_cles) => $feuille;
+                }
+            } else {
+                yield [$cle] => $branche;
+            }
         }
     }
 
     // ArrayAccess
-    public function offsetExists($cles): bool {
-        if (!count($cles)) {
-            return false;
-        }
-        $cle = array_shift($cles);
-        if (count($cles)) {
-            return $this->noeud[$cle]->offsetExists($cles);
-        } else {
-            return isset($this->noeud[$cles[0]]);
-        }
+    public function offsetSet($string, $valeur): void {
+        $this->arraySet(str_split($string), $valeur);
     }
 
-    public function offsetGet($cles): mixed {
-        if (!count($cles)) {
-            throw new \OutOfBoundsException("Liste de clés vide.");
-        }
-        $cle = array_shift($cles);
-        if (!isset($this->noeud[$cle])) $this->noeud[$cle] = new Trie();
-        if (count($cles)) {
-            return $this->noeud[$cle]->offsetGet($cles);
-        } else {
-            return $this->noeud[$cle];
-        }
+    public function offsetExists($string): bool {
+        return $this->arrayExists(str_split($string));
     }
 
-    public function offsetUnset($cles): void {
-        if ($this->offsetExists($cles)) {
-            $cle = array_shift($cles);
-            if (count($cles)) {
-                $this->noeud[$cle]->offsetUnset($cles);
-            } else {
-                unset($this->noeud[$cle]);
-            }
-        }
+    public function &offsetGet($string): mixed {
+        return $this->arrayGet(str_split($string));
+    }
+
+    public function offsetUnset($string): void {
+        $this->arrayUnset(str_split($string));
     }
 
     // IteratorAggregate
-    public function getIterator(): Generator {
-        foreach ($this->noeud as $cle => $branche) {
-            if ($branche instanceof Trie) {
-                foreach($branche as $sous_cles => $feuille) {
-                    yield [$cle, ...$sous_cles] => $feuille;
-                }
-            } else {
-                yield $cle => $branche;
-            }
+    public function getIterator(): Traversable {
+        foreach($this->arrayIterator() as $array => $valeur) {
+            yield implode("", $array) => $valeur;
         }
     }
-}
+
+    // Countable
+    public function count(): int {
+        return $this->nb_branches;
+    }
+}

dico.php

@@ -6,48 +6,61 @@ const MIN_PREMIER_MOT = 1;
 const MIN_MOTS_SUIVANTS = 1;
 
 
-$dico = [[""]];
-if (($lecteur = fopen("dico.csv", "r")) !== FALSE) {
-    $header = fgetcsv($lecteur, 0, "\t");
-    while (($ligne = fgetcsv($lecteur, 0, "\t")) !== FALSE) {
-        if ($ligne[0] == NULL || substr($ligne[0], 0, 1) == "#") continue;
-        switch(count($ligne)) {
-            case 1:
-                [$mot] = $ligne;
-                $definition = "";
-            break;
-            case 2:
-                [$mot, $definition] = $ligne;
-            break;
-            case 3:
-                [$mot, $definition, $auteur] = $ligne;
-                $definition .= " <small><em>$auteur</em></small>";
-            break;
-        }
-        $mot = strtoupper($mot);
-        $longueur = strlen($mot);
-        if (!isset($dico[$longueur])) $dico[$longueur] = [];
-        if (!isset($dico[$longueur][$mot])) $dico[$longueur][$mot] = [];
-        if (strlen($definition)) $dico[$longueur][$mot][] = $definition;
+$nb_mots = 0;
+
+function dico($longueur_max) {
+    global $nb_mots;
+
+    $transliterator = Transliterator::createFromRules(':: Any-Latin; :: Latin-ASCII; :: NFD; :: [:Nonspacing Mark:] Remove; :: Upper(); :: NFC;', Transliterator::FORWARD);
+    
+    $dico = [[""]];
+    for ($longueur = 0; $longueur <= $longueur_max; $longueur++) {
+        $dico[] = new Trie();
     }
-    fclose($lecteur);
+    if (($lecteur = fopen("dico.csv", "r")) !== FALSE) {
+        $entete = fgetcsv($lecteur, 0, "\t");
+        while (($ligne = fgetcsv($lecteur, 0, "\t")) !== FALSE) {
+            if (
+                $ligne[0] == NULL
+                || substr($ligne[0], 0, 1) == "#"
+                || strlen($ligne[0]) > $longueur_max
+            ) continue;
+
+            $mot = $ligne[0];
+            $definitions = array_slice($ligne, 1);
+            $mot = str_replace("-", " ", $mot);
+            
+            $mot = $transliterator->transliterate($mot);
+            if (strpos($mot, " ") !== false) {
+                $mots = explode(" ", $mot);
+                $nb_mots = count($mots);
+                $mot = implode("", $mots);
+                foreach($definitions as $i => $definition) {
+                    $definitions[$i] .= " ($nb_mots mots)";
+                }
+            }
+
+            $longueur = strlen($mot);
+            $dico[$longueur][$mot] = $definitions;
+        }
+        fclose($lecteur);
+    }
+    
+    return $dico;
 }
 
-function tries($longueur_max) {
-    global $dico;
+function mots_espaces($longueur_max) {
+    global $nb_mots;
 
-    $_tries = [[]];
+    $dico = dico($longueur_max);
     for ($longueur = 1; $longueur <= $longueur_max; $longueur++) {
-        $_tries[$longueur] = new Trie();
-        foreach ($dico[$longueur] as $mot => $definition) {
-            $_tries[$longueur][str_split($mot)] = [];
-        }
         for ($position_espace = MIN_PREMIER_MOT; $position_espace + MIN_MOTS_SUIVANTS < $longueur; $position_espace++) {
-            $mots_suivants = $_tries[$longueur - $position_espace - 1];
-            foreach ($dico[$position_espace] as $premier_mot => $definition) {
-                $_tries[$longueur][str_split($premier_mot . " ")] = $mots_suivants;
+            $mots_suivants = $dico[$longueur - $position_espace - 1];
+            foreach ($dico[$position_espace]->arrayIterator() as $premier_mot => $definition) {
+                $premier_mot[] = " ";
+                $dico[$longueur]->arraySet($premier_mot, $mots_suivants);
             }
         }
     }
-    return $_tries;
-}
+    return $dico;
+}

index.php

@@ -1,12 +1,11 @@
 <?php
-include_once "dico.php";
 include_once "Grille.php";
 
 
-const HAUTEUR_DEFAUT = 6;
+const HAUTEUR_DEFAUT = 8;
 const HAUTEUR_MIN = 2;
 const HAUTEUR_MAX = 10;
-const LARGEUR_DEFAUT = 6;
+const LARGEUR_DEFAUT = 8;
 const LARGEUR_MIN = 2;
 const LARGEUR_MAX = 10;
 
@@ -31,8 +30,8 @@ $grille = new Grille($hauteur, $largeur);
 
 if (!isset($_GET["grille"]) || $_GET["grille"] == "") {
     do {
-        $id = $grille->genere();
-    } while (!$id);
+        $id = uniqid();
+    } while (!$grille->genere($id));
 
     $_GET["grille"] = $id;
     header("Location: " . dirname($_SERVER['DOCUMENT_URI']) . "?" . http_build_query($_GET));
@@ -41,16 +40,15 @@ if (!isset($_GET["grille"]) || $_GET["grille"] == "") {
 
 $id = htmlspecialchars($_GET["grille"]);
 
-$grille_valide = $grille->load($id) || $grille->genere();
+$grille_valide = $grille->load($id) || $grille->genere($id);
 
+mt_srand(crc32($id));
 if ($grille_valide) {
-    mt_srand(crc32($id));
-
     $definitions_horizontales = [];
     for ($y = 0; $y < $hauteur; $y++) {
         $definitions_horizontales[$y] = [];
         foreach ($grille->lignes[$y] as $mot) {
-            $definitions = $dico[strlen($mot)][$mot];
+            $definitions = $grille->dico[strlen($mot)][$mot];
             if (count($definitions)) {
                 $definitions_horizontales[$y][] = $definitions[mt_rand(0, count($definitions) - 1)];
             }
@@ -60,7 +58,7 @@ if ($grille_valide) {
     for ($x = 0 ; $x < $largeur; $x++) {
         $definitions_verticales[$x] = [];
         foreach ($grille->colonnes[$x] as $mot) {
-            $definitions = $dico[strlen($mot)][$mot];
+            $definitions = $grille->dico[strlen($mot)][$mot];
             if (count($definitions)) {
                 $definitions_verticales[$x][] = $definitions[mt_rand(0, count($definitions) - 1)];
             }