Discussion :

[selma89]

Bonjour,

J'aimerais savoir comment je peux écrire un algorithme pour composer un mot parmi 9 lettres.

Si par exemple, j'ai les lettres " a n f g r k d e h " le mot est "grande".

Merci

[druzy]

Pour ce genre de chose il te faut déjà un dictionnaire dans un fichier.
Puis il te reste plus qu'à tester toutes les solutions

[selma89]

oui ! je sais! , j'ai déjà un fichier dico.txt, mais je veux quelqu'un pour me guider un peu comment je dois raisonner.
En fait je cherche à améliorer mon jeu (en java) pour qu'il puisse donner au candidat les solutions possibles des mots parmi ces neuf lettres s'il ne trouve pas au moins une.

[druzy]

Il te suffit de tester si chaque possibilité est dans ton dico.

[Al_th]

1. Tu comptes le nombre de lettres présentes dans ton entrée (1a 1n 1f 1g 1r 1k 1d 1e 1h)

2.Pour chaque mot du dico, associer un tableau dans lesquelles tu comptes le nombre de chaque lettre ( 1 g, 1 r, 1 a, 1 n, 1 d, 1e ).

3.Pour chaque lettre du mots, tu verifies qu'il existe au moins n lettres que t'as rentré supérieur ou égale au nombre de lettres trouvée dans le mot du dico. Si le nombre de lettre est strictement inférieur ou 0, tu passe a la suite.

A chaque fois que tu trouves un mot tu l'met dans une file/pile/liste chainée ( pour éviter d'avoir une zone mémoire occupée trop grande quand tu sais pas combien de mots tu vas trouver qui vont effectivement être OK).

Et tu fais un random dans ta file/pile/liste chainée pour choper un mot qui te convient.

C'est sans doute pas la méthode la plus optimale, mais ca devrait marcher. Si quelqu'un a une autre proposition d'algo, j'suis preneur (pour voir a quoi ca ressemble)

[Mopmop]

Voilà comment j'aurais fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
 
 
    //Renvoi true si le mot peut etre écrit avec les lettres données
    private static boolean peutEtreEcrit(ArrayList<String> lesLettres, String mot)
    {
 
                //Si le mot est de longueur nulle c'est qu'on peut l'écrire
        if ( mot.length() == 0 )
            return true ;
 
                //On regarde si la première lettre du mot est contenue dans la liste des lettres (et on l'enlève le cas échéant)
        if (lesLettres.remove(String.valueOf(mot.charAt(0))) )            
            return peutEtreEcrit(lesLettres, mot.substring(1)) ;
 
                //Si on arrive la c'est que la première lettre du mot n'est pas comprise dans les lettres dispos : le mot ne peut donc pas être écrit.
        return false;
    }
 
    public static void main(String args[])
     {
        //Les lettres
         ArrayList<String> lesLettres = new ArrayList<String>() ;
         lesLettres.add("r") ;
         lesLettres.add("z") ;
         lesLettres.add("t") ;
         lesLettres.add("a") ;
         lesLettres.add("t") ;
         lesLettres.add("e") ;
         lesLettres.add("m") ;
 
 
         //Les mots du dico
         ArrayList<String> lesMotsDuDico = new ArrayList<String>();
         lesMotsDuDico.add("tarte") ;
         lesMotsDuDico.add("zerta") ;
         lesMotsDuDico.add("bluelur") ;
 
 
         //Les mots du dico qui peuvent être écrits avec les lettres données
         ArrayList<String> lesMotsQuiPeuventEtreEcrits = new ArrayList<String>() ;
 
 
         //Boucle sur les mots du dico
         for (String mot : lesMotsDuDico)         
             if ( mot.length() <= lesLettres.size() ) //Si le mot contient trop de lettres, pas la peine de tester
             {
                 ArrayList<String> temporaire = new ArrayList<String>(lesLettres) ;
                 if (peutEtreEcrit(temporaire, mot))
                     lesMotsQuiPeuventEtreEcrits.add(mot) ;
             }
 
      System.out.println("Les mots qui peuvent être ecrits : "+lesMotsQuiPeuventEtreEcrits) ;
 
     }

Je sais pas si c'est la meilleure solution, mais je pense qu'elle est meilleure que celle de Al_th (elle n'est pas très différente, mais je saute le comptage des lettres).

La version itérative :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    private static boolean peutEtreEcrit(ArrayList<String> lesLettres, String mot)
    {
        while (lesLettres.remove(String.valueOf(mot.charAt(0))))
            if ( mot.length() == 1 )
                return true ;
            else 
                mot = mot.substring(1) ;
 
        return false;
    }

Itératif vs récursif... encore et toujours

[braxxe]

Bonjour,

Tu peux t'inspirer du travail de Paul Courbis: Ici
Puisque ça ressemble à ce que tu veux faire.
J’espère que ça t'aideras.