diff --git a/index0.php b/index0.php
deleted file mode 100644
index f938d68..0000000
--- a/index0.php
+++ /dev/null
@@ -1,258 +0,0 @@
-<?php
-ini_set('display_errors', 1);
-ini_set('html_errors', 1);
-ini_set('error_reporting', E_ALL);
-
-$default_lignes = 3;
-$default_colonnes = 4;
-
-$hauteur = filter_input(INPUT_GET, 'lignes', FILTER_VALIDATE_INT, [
-    "options" => [
-        "default" => $default_lignes,
-        "min_range" => 2,
-        "max_range" => 10
-    ]
-]);
-$largeur = filter_input(INPUT_GET, 'colonnes', FILTER_VALIDATE_INT, [
-    "options" => [
-        "default" => $default_colonnes,
-        "min_range" => 2,
-        "max_range" => 10
-    ]
-]);
-
-$dico = [];
-if (($handle = fopen("dico.csv", "r")) !== FALSE) {
-    $header = fgetcsv($handle, 0, "\t");
-    while (($ligne = fgetcsv($handle, 0, "\t")) !== FALSE) {
-        if (count($ligne) >= 2) {
-            $mot = $ligne[0];
-            $definition = $ligne[1];
-            $dico[$mot] = $definition;
-        }
-    }
-    fclose($handle);
-}
-
-$mots_de_n_lettres = [];
-foreach ($dico as $mot => $definition) {
-    $n = strlen($mot);
-    if (!isset($mots_de_n_lettres[$n])) {
-        $mots_de_n_lettres[$n] = [];
-    }
-    $mots_de_n_lettres[$n][] = $mot;
-}
-foreach ($mots_de_n_lettres as $n => $liste_mots) {
-    shuffle($mots_de_n_lettres[$n]);
-}
-
-$mots_par_position = [];
-foreach ([$hauteur, $largeur] as $n) {
-    $mots_par_position[$n] = [];
-    foreach ($mots_de_n_lettres[$n] as $mot) {
-        foreach (str_split($mot) as $i => $lettre) {
-            if (!isset($mots_par_position[$n][$i])) {
-                $mots_par_position[$n][$i] = [];
-            }
-            if (!isset($mots_par_position[$n][$i][$lettre])) {
-                $mots_par_position[$n][$i][$lettre] = [];
-            }
-            $mots_par_position[$n][$i][$lettre][] = $mot;
-        }
-    }
-}
-
-function pire_contrainte($tests, $nb_lettres, $i, $mot)
-{
-    global $mots_par_position;
-    $nb_mots_min = PHP_INT_MAX;
-    $pire_contrainte = 0;
-    foreach ($tests as $test) {
-        if (
-            !array_key_exists($i, $mots_par_position[$nb_lettres]) ||
-            !array_key_exists($mot[$test], $mots_par_position[$nb_lettres][$i])
-        ) {
-            return -1;
-        } else {
-            $nb_mots = count($mots_par_position[$nb_lettres][$i][$mot[$test]]);
-            if ($nb_mots < $nb_mots_min) {
-                $pire_contrainte = $test;
-                $nb_mots_min = $nb_mots;
-            }
-        }
-    }
-    return $pire_contrainte;
-}
-
-
-class Grille
-{
-    public $hauteur;
-    public $largeur;
-    public $grille;
-    public $lignes_restantes;
-    public $colonnes_restantes;
-
-    public function __construct($hauteur, $largeur)
-    {
-        $this->hauteur = $hauteur;
-        $this->largeur = $largeur;
-        $this->grille = array_fill(0, $hauteur, array_fill(0, $largeur, '.'));
-        $this->lignes_restantes = range(0, $hauteur - 1);
-        $this->colonnes_restantes = range(0, $largeur - 1);
-    }
-
-    public function get_ligne($l)
-    {
-        return implode("", $this->grille[$l]);
-    }
-
-    public function set_ligne($l, $mot)
-    {
-        for ($i = 0; $i < strlen($mot); $i++) {
-            $this->grille[$l][$i] = $mot[$i];
-        }
-    }
-    public function get_colonne($c)
-    {
-        $colonne = "";
-        for ($i = 0; $i < $this->hauteur; $i++) {
-            $colonne .= $this->grille[$i][$c];
-        }
-        return $colonne;
-    }
-    public function set_colonne($c, $mot)
-    {
-        for ($i = 0; $i < strlen($mot); $i++) {
-            $this->grille[$i][$c] = $mot[$i];
-        }
-    }
-    
-    public function genere()
-    {
-        global $mots_de_n_lettres;
-
-        $l = $this->largeur / 2;
-        array_splice($this->lignes_restantes, $l, 1);
-        foreach ($mots_de_n_lettres[$this->largeur] as $mot_lig) {
-            $this->set_ligne($l, $mot_lig);
-            yield from $this->trouve_une_colonne($l, $mot_lig);
-        }
-        $this->lignes_restantes[] = $l;
-        $this->grille[$l] = array_fill(0, $this->largeur, '.');
-    }
-
-    public function trouve_une_colonne($l, $mot_lig)
-    {
-        global $mots_par_position;
-
-        $c = pire_contrainte($this->colonnes_restantes, $this->hauteur, $l, $mot_lig);
-        if ($c == -1) {
-            return;
-        }
-        $colonne = $this->get_colonne($c);
-        array_splice($this->colonnes_restantes, $c, 1);
-        foreach ($mots_par_position[$this->hauteur][$l][$mot_lig[$c]] as $mot_col) {
-            if ($mot_col == $colonne || preg_match("/^$colonne$/", $mot_col)) {
-                $this->set_colonne($c, $mot_col);
-                if (count($this->lignes_restantes)) {
-                    yield from $this->trouve_une_ligne($c, $mot_col);
-                } else if (count($this->colonnes_restantes)) {
-                    yield from $this->trouve_une_colonne($l, $mot_lig);
-                } else {
-                    yield;
-                }
-            }
-        }
-        $this->colonnes_restantes[] = $c;
-        $this->set_colonne($c, $colonne);
-    }
-
-    public function trouve_une_ligne($c, $mot_col)
-    {
-        global $mots_par_position;
-
-        $l = pire_contrainte($this->lignes_restantes, $this->largeur, $c, $mot_col);
-        if ($l == -1) {
-            return;
-        }
-        $ligne = $this->get_ligne($l);
-        array_splice($this->lignes_restantes, $l, 1);
-        foreach ($mots_par_position[$this->largeur][$c][$mot_col[$l]] as $mot_lig) {
-            if ($mot_lig == $ligne || preg_match("/^$ligne$/", $mot_lig)) {
-                $this->set_ligne($l, $mot_lig);
-                if (count($this->colonnes_restantes)) {
-                    yield from $this->trouve_une_colonne($l, $mot_lig);
-                } else if (count($this->lignes_restantes)) {
-                    yield from $this->trouve_une_ligne($c, $mot_col);
-                } else {
-                    yield;
-                }
-            }
-        }
-        $this->lignes_restantes[] = $l;
-        $this->set_ligne($l, $ligne);
-    }
-
-    public function affiche()
-    {
-        echo "<table>";
-        echo "<tr><th></th>";
-        for ($c = 0; $c < $this->largeur; $c++) {
-            echo "<th>" . chr($c + 65) . "</th>";
-        }
-        echo "</tr>";
-        for ($l = 0; $l < $this->hauteur; $l++) {
-            echo "<tr><th>" . $l . "</th>";
-            for ($c = 0; $c < $this->largeur; $c++) {
-                echo "<td>" . $this->grille[$l][$c] . "</td>";
-            }
-            echo "</tr>";
-        }
-        echo "</table>";
-    }
-}
-
-$grille = new Grille($hauteur, $largeur);
-$grille->genere()->current();
-
-?>
-<!DOCTYPE HTML>
-<html>
-
-<head>
-    <meta charset="utf-8">
-    <title>Mots croisés</title>
-    <style>
-        table {
-            border-collapse: collapse;
-        }
-
-        td {
-            width: 30px;
-            height: 30px;
-            text-align: center;
-            border: 1px solid black;
-        }
-    </style>
-</head>
-
-<body>
-    <table>
-        <tr>
-            <th></th>
-            <?php for ($c = 0; $c < $largeur; $c++): ?>
-                <th><?= chr($c + 65) ?></th>
-            <?php endfor; ?>
-        </tr>
-        <?php for ($l = 0; $l < $hauteur; $l++): ?>
-            <tr>
-                <th><?= $l ?></th>
-                <?php for ($c = 0; $c < $largeur; $c++): ?>
-                    <td><?= $grille->grille[$l][$c] ?></td>
-                <?php endfor; ?>
-            </tr>
-        <?php endfor; ?>
-    </table>
-
-</html>
\ No newline at end of file
diff --git a/test1.py b/test.py
similarity index 100%
rename from test1.py
rename to test.py
diff --git a/test0.py b/test0.py
deleted file mode 100644
index 86129dc..0000000
--- a/test0.py
+++ /dev/null
@@ -1,181 +0,0 @@
-import csv
-from re import compile, match
-from random import choice, sample, randrange
-from collections import defaultdict
-from math import ceil
-from itertools import product, chain
-
-
-dico = defaultdict(list)
-with open("dico.csv", "r", encoding="utf-8") as fichier:
-    for mot, definition in csv.reader(fichier, delimiter="\t"):
-        if not mot.startswith("#"):
-            dico[mot].append(definition)
-
-mots = defaultdict(set)
-for mot in dico:
-    mots[len(mot)].add(mot)
-
-def melange(iterable):
-    liste = list(iterable)
-    return sample(liste, len(liste))
-
-def mots_de_n_lettres(n):
-    for mot in mots[n]:
-        yield mot
-    # for mot in mots[n-1]:
-    #     yield f"{mot} "
-    #     yield f" {mot}"
-    for i in range(2, ceil(n / 2)):
-        for mot1, mot2 in product(mots[i], mots_de_n_lettres(n - i - 1)):
-            yield f"{mot1} {mot2}"
-            yield f"{mot2} {mot1}"
-        # for mot1, mot2 in product(mots[i], mots_de_n_lettres(n - i - 2)):
-        #     yield f" {mot1} {mot2}"
-        #     yield f"{mot2} {mot1} "
-        # for mot1, mot2 in product(mots[i-1], mots_de_n_lettres(n - i - 1)):
-        #     yield f" {mot1} {mot2}"
-        #     yield f"{mot2} {mot1} "
-
-
-class Ligne:
-    def __init__(self, grille):
-        self.grille = grille
-
-    def __getitem__(self, n):
-        return "".join(self.grille[n])
-
-    def __setitem__(self, n, mot):
-        self.grille[n] = list(mot)
-
-
-class Colonne:
-    def __init__(self, grille):
-        self.grille = grille
-
-    def __getitem__(self, n):
-        return "".join(ligne[n] for ligne in self.grille)
-
-    def __setitem__(self, n, mot):
-        for i, char in enumerate(mot):
-            self.grille[i][n] = char
-
-
-class Grille:
-    def __init__(self, hauteur, largeur):
-        self.hauteur = hauteur
-        self.largeur = largeur
-        self.grille = [["." for _ in range(largeur)] for _ in range(hauteur)]
-        self.ligne = Ligne(self.grille)
-        self.colonne = Colonne(self.grille)
-
-        self.mots_de_n_lettres = {
-            hauteur: set(mots_de_n_lettres(hauteur)),
-            largeur: set(mots_de_n_lettres(largeur)),
-        }
-        self.mots_par_position = defaultdict(lambda: defaultdict(list))
-        for nb_lettres in (self.largeur, self.hauteur):
-            for mot in self.mots_de_n_lettres[nb_lettres]:
-                for i, lettre in enumerate(mot):
-                    self.mots_par_position[nb_lettres][(i, lettre)].append(mot)
-
-        self.generations = self.genere()
-        try:
-            next(self)
-        except StopIteration:
-            pass
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return next(self.generations)
-
-    def genere(self):
-        self.lignes_restantes = set(range(self.hauteur))
-        self.colonnes_restantes = set(range(self.largeur))
-
-        l = 0
-        self.lignes_restantes.remove(l)
-        for mot_lig in self.mots_de_n_lettres[self.largeur]:
-            if ' ' in mot_lig:
-                continue
-            self.ligne[l] = mot_lig
-            yield from self.trouve_une_colonne(l, mot_lig)
-        #self.ligne[l] = "." * self.largeur
-        #self.lignes_restantes.add(l)
-
-    def trouve_une_colonne(self, l, mot_lig):
-        #print((len(self.colonnes_restantes) + len(self.lignes_restantes)) / (self.largeur + self.hauteur))
-        #print(self)
-        c = min(
-            self.colonnes_restantes,
-            key=lambda c: len(self.mots_par_position[self.hauteur][(l, mot_lig[c])])
-        )
-        if not self.mots_par_position[self.hauteur][(l, mot_lig[c])]:
-            return
-        colonne = self.colonne[c]
-        self.colonnes_restantes.remove(c)
-        pattern = compile(rf"\b{colonne}\b")
-        for mot_col in self.mots_par_position[self.hauteur][(l, mot_lig[c])]:
-            if colonne == mot_col or ('.' in colonne and pattern.match(mot_col)):
-                self.colonne[c] = mot_col
-                if self.lignes_restantes:
-                    yield from self.trouve_une_ligne(c, mot_col)
-                elif self.colonnes_restantes:
-                    yield from self.trouve_une_colonne(l, mot_lig)
-                else:
-                    yield self
-        self.colonne[c] = colonne
-        self.colonnes_restantes.add(c)
-
-    def trouve_une_ligne(self, c, mot_col):
-        l = min(
-            self.lignes_restantes,
-            key=lambda l: len(self.mots_par_position[self.largeur][(c, mot_col[l])])
-        )
-        if not self.mots_par_position[self.largeur][(c, mot_col[l])]:
-            return
-        ligne = self.ligne[l]
-        self.lignes_restantes.remove(l)
-        pattern = compile(rf"\b{ligne}\b")
-        for mot_lig in self.mots_par_position[self.largeur][(c, mot_col[l])]:
-            if ligne == mot_lig or ('.' in ligne and pattern.match(mot_lig)):
-                self.ligne[l] = mot_lig
-                if self.colonnes_restantes:
-                    yield from self.trouve_une_colonne(l, mot_lig)
-                elif self.lignes_restantes:
-                    yield from self.trouve_une_ligne(c, mot_col)
-                else:
-                    yield self
-        self.ligne[l] = ligne
-        self.lignes_restantes.add(l)
-
-    def __str__(self):
-        return (
-            "   "
-            + " ".join(chr(65 + i) for i in range(self.largeur))
-            + "\n"
-            + "\n".join(
-                f"{i + 1:2} " + " ".join(ligne) for i, ligne in enumerate(self.grille)
-            )
-        )
-
-    def __repr__(self):
-        return self.__str__()
-
-
-if __name__ == "__main__":
-    import time
-
-    class Timer:
-        def __enter__(self):
-            self.start = time.time()
-            return self
-
-        def __exit__(self, *exc_info):
-            end = time.time()
-            print(f"Execution time: {end - self.start:.2f} seconds")
-
-    with Timer():
-        print(Grille(5, 5))
diff --git a/test2.py b/test2.py
deleted file mode 100644
index 029b1f7..0000000
--- a/test2.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import csv
-from re import compile, match
-from random import choice, sample, randrange
-from collections import defaultdict
-from math import ceil
-from itertools import product, chain
-
-
-dico = defaultdict(list)
-with open("dico.csv", "r", encoding="utf-8") as fichier:
-    for mot, definition in csv.reader(fichier, delimiter="\t"):
-        if not mot.startswith("#"):
-            dico[mot].append(definition)
-
-mots_de_n_lettres = defaultdict(set)
-for mot in dico:
-    mots_de_n_lettres[len(mot)].add(mot)
-
-
-def mots_espaces(n):
-    for mot in mots_de_n_lettres[n]:
-        yield mot
-    # for mot in mots_de_n_lettres[n-1]:
-    #     yield f"{mot} "
-    #     yield f" {mot}"
-    for i in range(2, ceil(n / 2)):
-        for mot1, mot2 in product(mots_de_n_lettres[i], mots_espaces(n - i - 1)):
-            yield f"{mot1} {mot2}"
-            yield f"{mot2} {mot1}"
-        # for mot1, mot2 in product(mots_de_n_lettres[i], mots_espaces(n - i - 2)):
-        #     yield f" {mot1} {mot2}"
-        #     yield f"{mot2} {mot1} "
-        # for mot1, mot2 in product(mots_de_n_lettres[i-1], mots_espaces(n - i - 1)):
-        #     yield f" {mot1} {mot2}"
-        #     yield f"{mot2} {mot1} "
-
-
-class Ligne:
-    def __init__(self, grille):
-        self.grille = grille
-
-    def __getitem__(self, n):
-        return "".join(self.grille[n])
-
-    def __setitem__(self, n, mot):
-        self.grille[n] = list(mot)
-
-
-class Colonne:
-    def __init__(self, grille):
-        self.grille = grille
-
-    def __getitem__(self, n):
-        return "".join(ligne[n] for ligne in self.grille)
-
-    def __setitem__(self, n, mot):
-        for i, char in enumerate(mot):
-            self.grille[i][n] = char
-
-
-class Grille:
-    def __init__(self, hauteur, largeur):
-        self.hauteur = hauteur
-        self.largeur = largeur
-        self.grille = [["." for _ in range(largeur)] for _ in range(hauteur)]
-        self.ligne = Ligne(self.grille)
-        self.colonne = Colonne(self.grille)
-
-        self.mot_commencant_par = defaultdict(lambda: defaultdict(list))
-        self.mots_finissant_par = defaultdict(lambda: defaultdict(list))
-        for dimension in (hauteur,) if hauteur == largeur else (hauteur, largeur):
-            for mot in mots_espaces(dimension):
-                for i in range(dimension+1):
-                    self.mot_commencant_par[dimension][mot[:i]].append(mot)
-                    self.mots_finissant_par[dimension][mot[i:]].append(mot)
-
-        self.grilles = self.genere_grilles()
-        next(self.grilles)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return next(self.grilles)
-
-    def genere_grilles(self):
-        yield from self.trouve_une_ligne(0)
-
-    def trouve_une_ligne(self, i):
-        for mot in self.mots_finissant_par[self.largeur][self.ligne[i][self.largeur-i:]]:
-            self.ligne[i] = mot
-            if i < self.largeur:
-                yield from self.trouve_une_colonne(i)
-            elif i + 1 < self.hauteur:
-                yield from self.trouve_une_ligne(i + 1)
-            else:
-                yield self
-
-    def trouve_une_colonne(self, i):
-        for mot in self.mot_commencant_par[self.hauteur][self.colonne[self.largeur-1-i][:i+1]]:
-            self.colonne[self.largeur-1-i] = mot
-            if i + 1 < self.hauteur:
-                yield from self.trouve_une_ligne(i + 1)
-            elif i + 1 < self.largeur:
-                yield from self.trouve_une_colonne(i + 1)
-            else:
-                yield self
-
-    def __str__(self):
-        return (
-            "   "
-            + " ".join(chr(65 + i) for i in range(self.largeur))
-            + "\n"
-            + "\n".join(
-                f"{i + 1:2} " + " ".join(ligne) for i, ligne in enumerate(self.grille)
-            )
-        )
-
-    def __repr__(self):
-        return self.__str__()
-
-
-if __name__ == "__main__":
-    import time
-
-    class Timer:
-        def __enter__(self):
-            self.start = time.time()
-            return self
-
-        def __exit__(self, *exc_info):
-            end = time.time()
-            print(f"Execution time: {end - self.start:.2f} seconds")
-
-    with Timer():
-        print(Grille(5, 5))