autoriser autant de doublons que de définitions,

suppression de la limite de mots

Grille.php

@@ -34,13 +34,12 @@ class Grille implements Iterator, ArrayAccess {
         $this->lettres_suivantes = [];
         foreach ($hauteur == $largeur ? [$hauteur] : [$hauteur, $largeur] as $longueur) {
             $this->lettres_suivantes[$longueur] = [];
-            foreach (mots_espaces($longueur, $hauteur == $largeur ? MAX_MOTS : MAX_MOTS/2) as $mot) {
+            foreach (mots_espaces($longueur) as $mots) {
+                $mot = implode(" ", $mots);
                 $ref = &$this->lettres_suivantes[$longueur];
                 for ($i = 0; $i < $longueur; $i++) {
                     $lettre = $mot[$i];
-                    if (!isset($ref[$lettre])) {
-                        $ref[$lettre] = [];
-                    }
+                    if (!isset($ref[$lettre])) $ref[$lettre] = [];
                     $ref = &$ref[$lettre];
                 }
                 $ref = [];
@@ -49,10 +48,9 @@ class Grille implements Iterator, ArrayAccess {
 
         $this->positions = [];
         for ($y = 0; $y < $hauteur; $y++) {
-            for ($x = 0; $x < $largeur; $x++) {
+            for ($x = 0; $x < $largeur; $x++)
                 $this->positions[] = [$x, $y];
         }
-        }
         $this->nb_positions = count($this->positions);
 
         mt_srand($id == "" ? null : crc32($id));
@@ -62,23 +60,23 @@ class Grille implements Iterator, ArrayAccess {
     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;
     }
 
     public function get_colonne($x, $hauteur)
     {
         $colonne = "";
-        for ($y = 0; $y < $hauteur; $y++) {
+        for ($y = 0; $y < $hauteur; $y++)
             $colonne .= $this->grille[$y][$x];
-        }
         return $colonne;
     }
 
     public function generateur($i = 0)
     {
+        global $dico;
+
         if ($i == $this->nb_positions) {
             yield $this;
             return;
@@ -87,13 +85,11 @@ class Grille implements Iterator, ArrayAccess {
         [$x, $y] = $this->positions[$i];
 
         $lettres_suivantes_ligne = $this->lettres_suivantes[$this->largeur];
-        for ($x2 = 0; $x2 < $x; $x2++) {
+        for ($x2 = 0; $x2 < $x; $x2++)
             $lettres_suivantes_ligne = $lettres_suivantes_ligne[$this->grille[$y][$x2]];
-        }
         $lettres_suivantes_colonne = $this->lettres_suivantes[$this->hauteur];
-        for ($y2 = 0; $y2 < $y; $y2++) {
+        for ($y2 = 0; $y2 < $y; $y2++)
             $lettres_suivantes_colonne = $lettres_suivantes_colonne[$this->grille[$y2][$x]];
-        }
         $lettres_communes = melanger_cles(array_intersect_key(
             $lettres_suivantes_ligne,
             $lettres_suivantes_colonne
@@ -103,32 +99,32 @@ class Grille implements Iterator, ArrayAccess {
             $this->grille[$y][$x] = $lettre;
 
             if ($x == $this->largeur - 1) {
-                $mots_ligne = explode(" ", $this->get_ligne($y, $this->largeur));
-                foreach ($mots_ligne as $mot_ligne) {
-                    if (in_array($mot_ligne, array_merge(...$this->lignes, ...$this->colonnes))) {
-                        continue 2;
+                foreach (explode(" ", $this->get_ligne($y, $this->largeur)) as $mot) {
+                    if (strlen($mot) == 1) continue;
+                    $nb_definitions = count($dico[strlen($mot)][$mot]);
+                    $occurences = 1;
+                    foreach (array_merge(...$this->lignes, ...$this->colonnes) as $mot2) {
+                        if ($mot != $mot2) continue;
+                        if (++$occurences >= $nb_definitions) continue 3;
                     }
-                    if (!isset($this->lignes[$y])) {
+                    $this->lignes[$y][] = $mot;
+                }
+            } else {
                 $this->lignes[$y] = [];
             }
-                    $this->lignes[$y][] = $mot_ligne;
-                }
-            } else {
-                unset($this->lignes[$y]);
-            }
             if ($y == $this->hauteur - 1) {
-                $mots_colonne = explode(" ", $this->get_colonne($x, $this->hauteur));
-                foreach ($mots_colonne as $mot_colonne) {
-                    if (in_array($mot_colonne, array_merge(...$this->lignes, ...$this->colonnes))) {
-                        continue 2;
+                foreach (explode(" ", $this->get_colonne($x, $this->hauteur)) as $mot) {
+                    if (strlen($mot) == 1) continue;
+                    $nb_definitions = count($dico[strlen($mot)][$mot]);
+                    $occurences = 1;
+                    foreach (array_merge(...$this->lignes, ...$this->colonnes) as $mot2) {
+                        if ($mot != $mot2) continue;
+                        if (++$occurences >= $nb_definitions) continue 3;
                     }
-                    if (!isset($this->lignes[$x])) {
-                        $this->colonnes[$x] = [];
-                    }
-                    $this->colonnes[$x][] = $mot_colonne;
+                    $this->colonnes[$x][] = $mot;
                 }
             } else {
-                unset($this->colonnes[$x]);
+                $this->colonnes[$x] = [];
             }
 
             if ($i < $this->nb_positions) {
@@ -142,9 +138,8 @@ class Grille implements Iterator, ArrayAccess {
     public function hash()
     {
         $string = "";
-        foreach ($this->grille as $ligne) {
+        foreach ($this->grille as $ligne)
             $string .= implode("", $ligne);
-        }
         return hash('sha256', $string);
     }
 

dico.csv

@@ -2989,134 +2989,3 @@ AINE	Fin de semaine
 IS	Sur la Tille
 IO	Bête à manger du foin
 CIL	On l'a à l'œil
-ACID	Propriétés garantissant la fiabilité des transactions dans les bases de données (atomicité, cohérence, isolation, durabilité).
-ADMINISTRATEUR	Personne responsable de la gestion, de la configuration et de la maintenance des systèmes informatiques, réseaux ou applications, veillant à leur bon fonctionnement, leur sécurité et leur disponibilité pour les utilisateurs.
-ANSIBLE	Outil open source pour automatiser la gestion des configurations et déploiements.
-APPLICATIF	Ensemble des logiciels ou applications utilisés dans une organisation pour répondre à des besoins spécifiques, comme la gestion commerciale, la paie, ou le traitement de données, et qui s’exécutent sur une infrastructure informatique.
-APPLICATION	Logiciel conçu pour accomplir une tâche spécifique, qu’il s’agisse d’une utilisation personnelle comme un jeu ou une application mobile ou professionnelle comme la gestion de données ou la comptabilité, en interagissant avec l’utilisateur et souvent en s’appuyant sur des systèmes ou réseaux.
-AWS	Plateforme de cloud computing proposant une large gamme de services comme le stockage, les bases de données, le calcul et l’analyse de données, permettant aux entreprises et développeurs de créer, héberger et faire évoluer des applications de manière flexible et à la demande.
-BGP	Protocole principal pour le routage entre réseaux sur internet.
-BIGDATA	L’ensemble des données volumineuses et complexes, difficiles à traiter avec les outils classiques, qui nécessitent des technologies spécifiques pour être collectées, stockées, analysées et exploitées afin d’en extraire des informations utiles. (2 mots)
-BLOCKCHAIN	Technologie de registre distribué sécurisé et transparent pour les transactions.
-BTREE	Structure de données optimisée pour les systèmes de stockage et bases de données.
-CICD	Pratiques automatisant le développement, le test et le déploiement des applications.
-CLOUD	L'ordinateur de quelqu'un d'autre
-CLUSTER	Ensemble d’ordinateurs interconnectés pour améliorer performances et disponibilité.
-CONFIGURER	Ajuster les paramètres et les réglages d’un système, logiciel ou matériel pour qu’il fonctionne selon les besoins spécifiques de l’utilisateur ou de l’environnement.
-CONFIGURE	Un appareil, un logiciel ou un système a été ajusté ou paramétré selon des spécifications particulières pour fonctionner de manière optimale ou répondre à des besoins spécifiques.
-CONTAINERIZATION	Encapsulation d’applications dans des conteneurs pour leur portabilité.
-CUDA	Plateforme Nvidia pour utiliser les GPU dans les calculs généraux.
-CPS	Systèmes intégrant composants informatiques et physiques.
-DATACENTER	Lieu physique ou virtuel où sont hébergés et gérés des infrastructures informatiques, comme des serveurs, des stockages et des systèmes de réseaux, destinés à supporter le fonctionnement d’applications, de services en ligne ou de traitements de données à grande échelle.
-DDOS	Attaque visant à rendre un service indisponible par saturation.
-DEPLOYER	Mettre en production un logiciel, une application ou une mise à jour sur un environnement opérationnel, rendant ainsi les nouvelles fonctionnalités ou corrections disponibles pour les utilisateurs finaux. Ce processus inclut souvent des étapes de configuration, de test et de validation.
-DEVELOPPEUR	Personne qui conçoit, crée et met en œuvre des logiciels, applications ou systèmes informatiques en utilisant des langages de programmation, en transformant les besoins utilisateurs en solutions fonctionnelles.
-DISTANT	Ce qui est séparé physiquement. En informatique désigne les ressources, appareils ou services accessibles depuis un endroit différent par un réseau, comme un serveur distant ou un accès à distance à un système.
-DOCKER	Plateforme simplifiant la création et exécution d’applications dans des conteneurs.
-DSI	La direction des systèmes d’information est le département d’une organisation responsable de la gestion, du développement et de la maintenance des outils et technologies numériques pour soutenir les activités et objectifs de l’entreprise.
-ELASTICSEARCH	Moteur de recherche distribué pour analyses rapides et scalables.
-ENVIRONNEMENTS	Configurations logicielles, matérielles et réseau dans lesquelles un système ou une application est développé, testé ou exploité, généralement divisés en environnements de développement, de test, de recette et de production pour assurer la qualité et la stabilité.
-ERP	Un système logiciel intégré qui permet de gérer et centraliser les différentes fonctions d’une entreprise (comptabilité, ressources humaines, supply chain, ventes, etc.) en unifiant les processus et les données pour améliorer l’efficacité opérationnelle et la prise de décision.
-ETHEREUM	Blockchain permettant contrats intelligents et applications décentralisées.
-FIDO	Normes pour authentification forte sans mot de passe.
-FPGA	Circuit programmable après fabrication pour performances spécifiques.
-FUZZ	Méthode injectant entrées aléatoires pour tester robustesse logicielle.
-GAN	Réseau comprenant générateur et discriminateur pour créer données synthétiques.
-GIT	Système de contrôle de version distribué qui permet de gérer et de suivre les modifications apportées à un ensemble de fichiers, facilitant ainsi la collaboration entre développeurs sur des projets logiciels enregistrant l’historique des changements.
-GPU	Un processeur spécialisé conçu pour traiter rapidement les données graphiques et les images, permettant de rendre les graphismes complexes dans les jeux vidéo, la 3d, le traitement d’images ou encore l’intelligence artificielle, en parallélisant les calculs nécessaires.
-GRAPHQL	Langage de requête permettant récupération précise de données via api.
-HADOOP	Framework pour traitement distribué de grandes quantités de données.
-HEBERGEUR	Prestataire de services qui met à disposition des ressources techniques (serveurs, stockage, bande passante) pour héberger des sites web, applications ou données en ligne, garantissant leur accessibilité depuis internet. Les hébergeurs peuvent également fournir des services annexes comme la sécurité, les sauvegardes et le support technique.
-HTTP	Protocole de communication utilisé pour transférer des données sur le world wide web, permettant aux navigateurs d’accéder à des ressources (comme des pages web) hébergées sur des serveurs via des requêtes et des réponses.
-HYPERCONVERGENCE	Architecture combinant stockage, calcul et réseau dans un seul système.
-IAC	Gestion automatique des infrastructures via fichiers configurables.
-IAAS	Est un modèle de cloud computing où une infrastructure matérielle (serveurs, stockage, réseaux) est mise à disposition via internet par un fournisseur, permettant aux utilisateurs de louer et gérer ces ressources à la demande sans avoir besoin d’investir dans du matériel physique. Exemples
-JAVA	Langage de programmation orienté objet, créé par sun microsystems (aujourd’hui oracle), qui permet de développer des applications fonctionnant sur différentes plateformes grâce à sa machine virtuelle java (jvm). Il est largement utilisé pour les logiciels d’entreprise, les applications mobiles
-JWT	Standard pour tokens sécurisant échanges entre parties.
-KUBERNETES	Plateforme pour gestion de conteneurs et orchestration d’applications.
-KAFKA	Plateforme pour flux de données en temps réel tolérante aux pannes.
-VM	Simulation logicielle d’un système informatique qui fonctionnent sur un ordinateur hôte, permettant d’exécuter plusieurs systèmes d’exploitation ou applications de manière isolée et indépendante, optimisant ainsi les ressources matérielles et facilitant le déploiement et les tests.
-MICROSERVICES	Architecture décomposant une application en services indépendants.
-AZURE	Plateforme de cloud computing proposant une large gamme de services (calcul, stockage, bases de données, intelligence artificielle, etc.) permettant aux entreprises et développeurs de créer, héberger et gérer des applications de manière flexible et évolutique, s’intégrant souvent avec l’écosystème microsoft.
-MIGRATION	Processus de transfert de données, d’applications ou de systèmes d’un environnement à un autre, comme lors du passage d’une infrastructure locale vers le cloud, d’une version logicielle ancienne vers une nouvelle, ou du changement de plateforme, tout en assurant la continuité et l’intégrité des informations.
-NAS	Dispositif de stockage connecté au réseau qui permet de centraliser et partager des données entre plusieurs utilisateurs ou appareils, offrant un accès facilité et une gestion simplifiée des fichiers via le réseau local ou internet
-NGINX	Serveur web et proxy inverse open source léger et haute performance, conçu pour gérer simultanément un grand nombre de connexions, idéal pour servir des sites web statiques, gérer le load balancing et agir comme passerelle vers des applications web.
-NLP	Intelligence artificielle traitant interaction langage humain-machine.
-NOSQL	Bases de données non relationnelles pour flexibilité et scalabilité.
-OAUTH	Protocole autorisant un accès limité à des ressources utilisateur sans partager les identifiants.
-OBSERVABILITE	Capacité d’un système à fournir informations internes pour diagnostic.
-ORACLE	Entreprise américaine spécialisée dans les logiciels et systèmes informatiques, principalement connue pour sa base de données relationnelle oracle database , largement utilisée pour stocker et gérer de grandes quantités d’informations de manière sécurisée et efficace.
-PAREFEU	Une barrière de sécurité qui contrôle et filtre les flux de données entrants et sortants sur un réseau ou un appareil, en se basant sur des règles définies, afin de protéger contre les accès non autorisés et les menaces potentielles.
-PIPELINE	Processus automatisant ingestion, traitement et transport de données.
-CPU	Composants électroniques au cœur des ordinateurs et appareils électroniques, chargés d’exécuter les instructions et les calculs nécessaires au fonctionnement des logiciels et systèmes, agissant comme le « cerveau » de l’ordinateur.
-PROTOCOLE	Ensemble de règles et de normes qui définissent comment les appareils, systèmes ou logiciels communiquent et échangent des données de manière structurée et efficace, comme par exemple le http pour le web ou le tcp/ip pour les réseaux.
-PROVISIONING	Allocation et configuration de ressources informatiques pour exécution.
-PROXY	Un serveur intermédiaire qui se place entre un appareil comme un ordinateur et un autre serveur par exemple, sur internet, permettant de relayer les requêtes et les réponses, tout en offrant des fonctions comme la sécurité, la mise en cache et l’anonymat.
-QUBIT	Unité fondamentale d’information en informatique quantique.
-RNN	Modélisation séquences comme texte ou parole.
-REQUÊTE	Demande d’information ou d’action formulée par un utilisateur ou un système auprès d’une base de données, d’un serveur ou d’une application, généralement exprimée dans un langage spécifique comme sql pour les bases de données ou http pour les requêtes web.
-RPA	Automatisation tâches répétitives par robots logiciels.
-SAAS	Logiciel hébergé accessible à partir d’internet.
-SDN	Gestion réseau programmable et centralisée.
-SERVEUR	Ordinateur ou logiciel qui fournit diverses ressources et services, comme le stockage de données, l’hébergement de sites web ou la gestion de courriels, aux appareils clients connectés sur un réseau.
-SHARDING	Partitionnement horizontal bases de données pour meilleure scalabilité.
-SOC	Centre surveillant incidents sécurité organisationnels.
-SQL	Langage de programmation conçu pour gérer et interroger les bases de données relationnelles, permettant d’effectuer des opérations comme la création, la lecture, la mise à jour et la suppression de données (crud) grâce à des requêtes structurées. Il est largement utilisé pour manipuler et organiser des ensembles de données complexes.
-SSH	Protocole de communication sécurisé qui permet d’accéder à distance et de gérer des systèmes informatiques de manière cryptée, offrant une connexion fiable et protégée contre les interceptions et les attaques. Il est couramment utilisé pour les transferts de fichiers sécurisés et l’administration à distance des serveurs.
-TERRAFORM	Outil iac définissant et provisionnant ressources cloud.
-TENSORFLOW	Bibliothèque open source pour calcul numérique et apprentissage automatique.
-TLS	Protocole sécurisant communications réseaux. Ce protocole remplace le ssl (secure sockets layer).
-TOKENISATION	Remplacement d’une donnée sensible comme un numéro de carte bancaire par un code unique, appelé token, utilisé uniquement pour une transaction spécifique. Cela protège vos informations en cachant le numéro réel.
-TYPESCRIPT	Sur-ensemble typé javascript offrant typage statique et interfaces.
-UML	Langage standardisé pour modélisation logicielle.
-UDP	Protocole rapide mais sans garantie livraison.
-URL	Adresse unique qui permet d’identifier et d’accéder à une ressource spécifique sur internet, comme une page web, un fichier ou une application, en indiquant son emplacement et le protocole à utiliser
-UX	Conception centrée utilisateur pour satisfaction.
-VIRTUALISATION	Technique qui consiste à faire fonctionner plusieurs systèmes ou applications sur un même ordinateur en les séparant les uns des autres pour optimiser les ressources et la sécurité.
-VLAN	Sous-réseaux logiques pour segmentation réseau.
-VPN	Connexion sécurisée sur réseau public.
-VCS	Système suivant modifications code pour collaboration.
-WAF	Sécurité filtrant trafic http(s) vers applications web.
-WEBASSEMBLY	Format binaire exécutant code haute performance dans navigateurs.
-WEBHOOK	Mécanisme qui permet d’envoyer automatiquement une notification à une autre application lorsqu’un événement spécifique se produit. Cela permet aux applications de communiquer entre elles en temps réel, sans avoir besoin de vérifier constamment les changements.
-SCRAPING	Technique d’extraction des données depuis le web à partir d’un script ou d’un logiciel dans le but de les étudier et de les transformer.
-WEBSOCKET	Protocole bidirectionnel temps réel entre client et serveur.
-XAAS	Services variés fournis sur le cloud.
-XML	Langage structurant et transportant données.
-XSS	Injection scripts malveillants dans sites web.
-YOCTO	Projet open source qui fournit des outils et des méthodes pour créer des systèmes d’exploitation linux personnalisés et optimisés, notamment utilisés dans l’embarqué et l’iot.
-ZB	Unité de mesure équivalente à environ un milliard de téraoctets, souvent utilisée pour représenter les volumes massifs de données générés par le big data.
-Ethernet	C'est le protocole standard pour les réseaux câblés. Définit comment les informations sont transmises via les câbles LAN.
-WiFi	Définit comment les appareils se connectent les uns aux autres sans câbles.
-PPP	Utilisé dans les connexions point à point, telles que les anciennes connexions par accès commuté, pour établir une communication directe entre deux nœuds.
-ARP	Traduit les adresses IP en adresses MAC au sein d'un réseau local afin que les données atteignent le bon appareil.
-STP	Évitez les boucles dans les réseaux locaux complexes en déconnectant les liens redondants qui pourraient causer des problèmes.
-IP	L'un des protocoles de base, il attribue des adresses uniques (IPv4 ou IPv6) et est responsable du routage des paquets vers leur destination.
-ICMP	Il complète l'IP en tant que système de diagnostic, envoyant des messages d'erreur ou confirmant si les paquets sont arrivés.
-RIP	Il aide les routeurs à échanger des informations sur les meilleurs itinéraires.
-DHCP	Automatise l'attribution d'adresses IP au sein d'un réseau local sans intervention manuelle.
-TCP	Garantit que tous les colis arrivent sans erreur, complets et dans le bon ordre.
-HTTP	Protocole principal du Web. Permet aux navigateurs et aux serveurs Web de communiquer.
-HTTPS	Version sécurisée cryptée avec TLS, utilisée sur les sites Web contenant des données sensibles.
-FTP	Utilisé pour télécharger et télécharger des fichiers entre les clients et les serveurs.
-SMTP	Protocole standard pour l'envoi d'e-mails.
-IMAP	Pour recevoir et gérer les e-mails provenant de serveurs distants.
-DNS	Traduit les adresses Web (domaines) en adresses IP, agissant comme un carnet d'adresses Internet global.
-SNMP	Facilite la gestion et la surveillance des périphériques réseau.
-PING	echo
-ECHO	ping
-FTP	Connexion FTP 
-TELNET	À éviter !
-SMTP	Protocole simple de transfert de courrier 
-NICNAME	Service d’annuaire WHOIS 
-TACACS	Protocole d’authentification à distance 
-TFTP	Protocole simplifié de transfert de fichiers 
-GOPHER	Recherche de document 
-KERBEROS	Système d’authentification de réseau 
-POP	Protocole de bureau de poste pour la communication par e-mail 
-NTP	Service de synchronisation temporelle 
-IMAP	Protocole d’accès aux messages électroniques
-SNMP	Protocole simple de gestion de réseau 
-IRC	Discussion relayée par Internet 
-LDAP	Annuaire moderne
-SYSLOG	Service de connexion au système Unix

dico.php

@@ -3,15 +3,12 @@
 
 const MIN_LETTRES_MOT_1 = 2;
 const MIN_LETTRES_MOT_2 = 0;
-const MAX_MOTS = 1000000;
 
 $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;
-        }
+        if ($ligne[0] == NULL || substr($ligne[0], 0, 1) == "#") continue;
         switch(count($ligne)) {
             case 1:
                 [$mot] = $ligne;
@@ -27,44 +24,26 @@ if (($lecteur = fopen("dico.csv", "r")) !== FALSE) {
         }
         $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;
-        }
+        if (!isset($dico[$longueur])) $dico[$longueur] = [];
+        if (!isset($dico[$longueur][$mot])) $dico[$longueur][$mot] = [];
+        if (strlen($definition)) $dico[$longueur][$mot][] = $definition;
     }
     fclose($lecteur);
 }
-foreach ($dico as $longueur => $mots) {
-    foreach ($mots as $mot => $definitions) {
-        if (count($definitions)) {
-            $dico[$longueur][$mot] = $definitions[array_rand($definitions)];
-        } else {
-            $dico[$longueur][$mot] = "";
-        }
-    }
-}
 
-function mots_espaces($longueur, $nb_mots_restants=MAX_MOTS)
+function mots_espaces($longueur)
 {
     global $dico;
 
     foreach ($dico[$longueur] as $mot => $definition) {
-        yield $mot;
-        if (--$nb_mots_restants <= 0) return;
+        yield [$mot];
     }
     for ($i = MIN_LETTRES_MOT_1; $longueur - $i - 1 >= MIN_LETTRES_MOT_2; $i++) {
-        foreach ($dico[$i] as $mot1 => $definition) {
-            foreach (mots_espaces($longueur - $i - 1, $nb_mots_restants) as $mot2) {
-                if ($mot1 != $mot2) {
-                    yield "$mot1 $mot2";
-                    if (--$nb_mots_restants <= 0) return;
-                    yield "$mot2 $mot1";
-                    if (--$nb_mots_restants <= 0) return;
+        foreach ($dico[$i] as $mot => $definition) {
+            foreach (mots_espaces($longueur - $i - 1) as $mots) {
+                if (!in_array($mot, $mots)) {
+                    yield [$mot, ...$mots];
+                    yield [...$mots, $mot];
                 }
             }
         }

index.php

@@ -1,21 +1,21 @@
 <?php
 
-if (!isset($_GET["grille"])) {
+if (isset($_GET["grille"])) {
+    $id = htmlspecialchars($_GET["grille"]);
+} else {
     $_GET["grille"] = uniqid();
     header("Location: " . dirname($_SERVER['DOCUMENT_URI']) . "?" . http_build_query($_GET));
     exit;
-} else {
-    $id = htmlspecialchars($_GET["grille"]);
 }
 
 
 include_once "dico.php";
 include_once "Grille.php";
 
-const HAUTEUR_DEFAUT = 7;
+const HAUTEUR_DEFAUT = 6;
 const HAUTEUR_MIN = 2;
 const HAUTEUR_MAX = 10;
-const LARGEUR_DEFAUT = 7;
+const LARGEUR_DEFAUT = 6;
 const LARGEUR_MIN = 2;
 const LARGEUR_MAX = 10;
 
@@ -37,25 +37,33 @@ $largeur = filter_input(INPUT_GET, 'colonnes', FILTER_VALIDATE_INT, [
 
 $grille = new Grille($hauteur, $largeur, $id);
 $grille->current();
-$definitions = [
-    "lignes" => [],
-    "colonnes" => []
-];
+
+function melanger_valeurs(&$tableau)
+{
+    usort($tableau, function ($a, $b) {
+        return mt_rand(-1, 1);
+    });
+}
+
+$definitions_horizontales = [];
 foreach ($grille->lignes as $y => $mots) {
-    $definitions["lignes"][$y] = [];
+    $definitions_horizontales[$y] = [];
     foreach ($mots as $mot) {
         $definition = $dico[strlen($mot)][$mot];
-        if ($dico[strlen($mot)][$mot] != "") {
-            $definitions["lignes"][$y][] = $definition;
+        if (count($definition)) {
+            melanger_valeurs($definition);
+            $definitions_horizontales[$y][] = array_pop($definition);
         }
     }
 }
+$definitions_verticales = [];
 foreach ($grille->colonnes as $x => $mots) {
-    $definitions["colonnes"][$x] = [];
+    $definitions_verticales[$x] = [];
     foreach ($mots as $mot) {
         $definition = $dico[strlen($mot)][$mot];
-        if ($dico[strlen($mot)][$mot] != "") {
-            $definitions["colonnes"][$x][] = $definition;
+        if (count($definition)) {
+            melanger_valeurs($definition);
+            $definitions_verticales[$x][] = array_pop($definition);
         }
     }
 }
@@ -116,14 +124,16 @@ foreach ($grille->colonnes as $x => $mots) {
                             <tr>
                                 <th><?= $y + 1 ?></th>
                                 <?php for ($x = 0; $x < $largeur; $x++): ?>
-                                    <td class="case <?= $grille[$y][$x] == " " ? "noire" : "blanche" ?>">
                                     <?php if ($grille[$y][$x] == " "): ?>
+                                        <td class="case noire">
                                             <input id="<?= chr($x + 65) . ($y + 1) ?>" type="text" maxlength="1" size="1" value=" " disabled />
-                                        <?php else: ?>
-                                            <input id="<?= chr($x + 65) . ($y + 1) ?>" type="text" maxlength="1" size="1" pattern="[A-Z]" placeholder="<?= $grille[$y][$x] ?>"
-                                                title="<?= "→ " . strip_tags(implode("\n→ ", $definitions["lignes"][$y])) . "\n↓ " . strip_tags(implode("\n↓ ", $definitions["colonnes"][$x])) ?>" />
-                                        <?php endif; ?>
                                         </td>
+                                    <?php else: ?>
+                                        <td class="case blanche">
+                                            <input id="<?= chr($x + 65) . ($y + 1) ?>" type="text" maxlength="1" size="1" pattern="[A-Z]" placeholder="<?= $grille[$y][$x] ?>"
+                                                title="<?= "→ " . strip_tags(implode("\n→ ", $definitions_horizontales[$y])) . "\n↓ " . strip_tags(implode("\n↓ ", $definitions_verticales[$x])) ?>" />
+                                        </td>
+                                    <?php endif; ?>
                                 <?php endfor; ?>
                             </tr>
                         <?php endfor; ?>
@@ -132,13 +142,13 @@ foreach ($grille->colonnes as $x => $mots) {
                 <div class="definitions horizontales">
                     <h2>Horizontalement</h2>
                     <ol>
-                        <?php foreach ($definitions["lignes"] as $y => $definitions_ligne): ?>
+                        <?php foreach ($definitions_horizontales as $y => $definitions): ?>
                             <li>
-                                <?php if (count($definitions_ligne) == 1): ?>
-                                    <?= $definitions_ligne[0] ?>
+                                <?php if (count($definitions) == 1): ?>
+                                    <?= $definitions[0] ?>
                                 <?php else: ?>
                                     <ol>
-                                        <?php foreach ($definitions_ligne as $definition) : ?>
+                                        <?php foreach ($definitions as $definition) : ?>
                                             <li><?= $definition ?></li>
                                         <?php endforeach ?>
                                     </ol>
@@ -150,13 +160,13 @@ foreach ($grille->colonnes as $x => $mots) {
                 <div class="definitions verticales">
                     <h2>Verticalement</h2>
                     <ol type="A">
-                        <?php foreach ($definitions["colonnes"] as $x => $definitions_colonne): ?>
+                        <?php foreach ($definitions_verticales as $x => $definitions): ?>
                             <li>
-                                <?php if (count($definitions_colonne) == 1): ?>
-                                    <?= $definitions_colonne[0] ?>
+                                <?php if (count($definitions) == 1): ?>
+                                    <?= $definitions[0] ?>
                                 <?php else: ?>
                                     <ol>
-                                        <?php foreach ($definitions_colonne as $definition) : ?>
+                                        <?php foreach ($definitions as $definition) : ?>
                                             <li><?= $definition ?></li>
                                         <?php endforeach ?>
                                     </ol>
@@ -165,7 +175,7 @@ foreach ($grille->colonnes as $x => $mots) {
                         <?php endforeach; ?>
                     </ol>
                 </div>
-            <?php else: ?>
+            <?php else: http_response_code(500); ?>
                 <h3 class="erreur">Erreur de génération de la grille</h3>
             <?php endif ?>
         </div>
@@ -174,9 +184,9 @@ foreach ($grille->colonnes as $x => $mots) {
             <img src="favicon.svg" width="16" height="16">
             <button type="submit">
                 Nouvelle grille de
-                <input type="number" id="lignes" name="lignes" value="<?= $hauteur ?>" min="<?=HAUTEUR_MIN?>" max="<?=HAUTEUR_MAX?>"/>
+                <input type="number" id="lignes"<?= isset($_GET["lignes"])? 'name="lignes"': "" ?> value="<?= $hauteur ?>" min="<?=HAUTEUR_MIN?>" max="<?=HAUTEUR_MAX?>"/>
                 lignes et
-                <input type="number" id="colonnes" name="colonnes" value="<?= $largeur ?>" min="<?=LARGEUR_MIN?>" max="<?=LARGEUR_MAX?>"/>
+                <input type="number" id="colonnes"<?= isset($_GET["colonnes"])? 'name="colonnes"': "" ?> value="<?= $largeur ?>" min="<?=LARGEUR_MIN?>" max="<?=LARGEUR_MAX?>"/>
                 colonnes
             </button>
         </div>

script.js

@@ -6,7 +6,7 @@ async function sha256(text) {
   return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
-let inputs = grilleForm.querySelectorAll('.grille input')
+let inputs = grilleForm.querySelectorAll(".grille input");
 let largeur = Number(colonnes.value);
 let nb_cases = inputs.length;
 let index = 0;
@@ -16,11 +16,19 @@ for (let input of inputs) {
   input.y = Math.floor(input.index / largeur);
 
   input.onfocus = function (event) {
-    for (li of document.querySelectorAll(`.definitions.horizontales > ol > li:nth-child(${input.y+1}), .definitions.verticales > ol > li:nth-child(${input.x+1})`)) {
-      li.classList.add("selectionee")
+    for (li of document.querySelectorAll(
+      `.definitions.horizontales > ol > li:nth-child(${
+        input.y + 1
+      }), .definitions.verticales > ol > li:nth-child(${input.x + 1})`
+    )) {
+      li.classList.add("selectionee");
     }
-    for (li of document.querySelectorAll(`.definitions.horizontales > ol > li:not(:nth-child(${input.y+1})), .definitions.verticales > ol > li:not(:nth-child(${input.x+1}))`)) {
-      li.classList.add("non-selectionee")
+    for (li of document.querySelectorAll(
+      `.definitions.horizontales > ol > li:not(:nth-child(${
+        input.y + 1
+      })), .definitions.verticales > ol > li:not(:nth-child(${input.x + 1}))`
+    )) {
+      li.classList.add("non-selectionee");
     }
 
     input.select();
@@ -69,17 +77,26 @@ for (let input of inputs) {
   };
 
   input.onblur = function (event) {
-    for (li of document.querySelectorAll(`.definitions.horizontales > ol > li:nth-child(${input.y+1}), .definitions.verticales > ol > li:nth-child(${input.x+1})`)) {
-      li.classList.remove("selectionee")
+    for (li of document.querySelectorAll(
+      `.definitions.horizontales > ol > li:nth-child(${
+        input.y + 1
+      }), .definitions.verticales > ol > li:nth-child(${input.x + 1})`
+    )) {
+      li.classList.remove("selectionee");
     }
-    for (li of document.querySelectorAll(`.definitions.horizontales > ol > li:not(:nth-child(${input.y+1})), .definitions.verticales > ol > li:not(:nth-child(${input.x+1}))`)) {
-      li.classList.remove("non-selectionee")
+    for (li of document.querySelectorAll(
+      `.definitions.horizontales > ol > li:not(:nth-child(${
+        input.y + 1
+      })), .definitions.verticales > ol > li:not(:nth-child(${input.x + 1}))`
+    )) {
+      li.classList.remove("non-selectionee");
     }
   };
-};
+}
 
-for (let input of grilleForm.querySelectorAll('.nouvelle-grille input')) {
+for (let input of grilleForm.querySelectorAll(".nouvelle-grille input")) {
   input.onfocus = function (event) {
+    input.name = input.id;
     input.select();
   };
 }