Explication de code

bonjour,
j'ai un programme du jeu "des chiffres et des lettre" (sans les chiffres) et je ne comprends pas une partie du code. help!
Comme je n'arrive pas a mettre le programme ici je l'enverrai en mp a qui pourra et voudra m'aider
merci,

3 réponses

  1. Faite juste un copier coller du code. Sans cela personne ne pourra vous aider…
    1. public boolean TestMot(String s, int indice) { // Fonction qui va testé si un mot existe dans l'arbre ou pas
              int j;                                      
              if (indice == s.length()) {
                  if (this.mots.contains(s)) {
                      return true;
                  } else {
                      return false;
                  }
              } else {
                  char c = s.charAt(indice);
                  int index = ((int) c - 97);
      
                  try {
                      this.fils[index].TestMot(s, indice + 1);
                  } catch (NullPointerException npe) {
                      System.out.println("pas de mots");
                  }
              }
              return false;
          }
      
          private ArrayList<String> TestListe(ArrayList<String> sacMot) { // Foncton qui va testé si les mots du noeud courant sont plus grand 
              int j;                                                      // que la liste qui stocke les mots les plus long
              if (!this.mots.isEmpty()) {
                  if (!sacMot.isEmpty()) {
                      if (sacMot.get(0).length() < this.mots.get(0).length()) {
                          sacMot = this.mots;
                      } else if (sacMot.get(0).length() == this.mots.get(0).length()) {
                          for (j = 0; j < this.mots.size(); j++) {
                              if (!sacMot.contains(this.mots.get(j))) {
                                  sacMot.add(this.mots.get(j));
                              }
                          }
                      }
                  } else {
                      sacMot = this.mots;
                  }
              }
              return sacMot;
          }
      
          public ArrayList<String> Recherche(String mot, String s, int prof, ArrayList<String> sacMot) { // Fonction recherche des mots les plus longs 
              int i, j;                                                                                  // stocké dans la liste sacMot 
      
              if (prof == mot.length()) {
                  sacMot = this.TestListe(sacMot);
              } else {
                  for (i = 0; i < s.length(); i++) {
                      char c = s.charAt(i);
                      int index = ((int) c - 97);
      
                      try {
                          sacMot = this.fils[index].Recherche(mot, s.substring(i + 1, s.length()), prof + 1 + i, sacMot);
                          sacMot = this.TestListe(sacMot);
                      } catch (NullPointerException npe) {
                          sacMot = this.TestListe(sacMot);
                      }
                  }
              }
              return sacMot;
          }
      }
    2. Modérateur
      @logma23Salut,

      La prochaine fois, pense bien à utiliser les balises code du forum, l’icône </>.
    3. dsl :/
    4. Est quel partie tu ne comprends pas ?
    5. @Felice_a partir de la foncton qui va tester si les mots du noeud courant sont plus grand
  2. Ta fonction ne fait que comparer deux tableaux.

    Elle vérifie simplement si le mot premier mot du tableau « sacMot » est plus petit en caractères.

    Si c'est le cas il remplace par le tableau « this.mots ».

    Dans le cas contraire il teste si le premier mot des deux tableaux ont le même nombre de caractères.

    Si c'est le cas il vérifie si le mot du tableau « this.mots » existe dans « sacMot ».

    S'il n'existe pas il l'ajoute.

    Enfin au début si « sacMot » est vide alors il reçois la valeur de « this.mots »

    La fonction retourne finalement le nouveau tableau de la variable « sacMot ».
    1. ici c'est dans un arbre que les mots d'un dictionnaire sont triés par ordre alphabétique et chaque lettre est stocké dans un noeud de l'arbre. Ca marche pareil?
    2. la Fonction recherche des mots les plus longs est celle que je n'arrive pas du tout a comprendre
  3. Modérateur
    Bonjour,

    "je ne comprends pas une partie du code"
    Il faut dire que le code en question est quand même particulièrement mal fichu... mais c'est le risque on prends le code d'un autre.

    Quelques commentaires sur le code :

    public ArrayList<String> // On ne devrait pas renvoyer la classe ArrayList mais l'interface List
            Recherche(// Le nom de la méthode devrait commencer par une minuscule
                    String mot, String s, int prof, ArrayList<String> sacMot) { // idem : sacMot devrait être une interface
        int i, j; // i ne devrait pas être déclaré ici mais dans la boucle for, j ne sert à rien
    
        if (prof == mot.length()) { // les noms sont mal choisis, on ne sait pas à quoi correspond "prof"
            sacMot = this.TestListe(sacMot); // on ne devrait pas réaffecter un argument de la méthode avec une autre valeur
        } else { // on peut se passer du else, il aurait fallu faire un return avant car dans le cas du if le résultat est déjà connu
            for (i = 0; i < s.length(); i++) { // c'est ici qu'il fallait déclarer int i;
                char c = s.charAt(i); // c n'est utilisé qu'une fois, on peut s'en passer
                int index = ((int) c - 97); // 97 n'est pas intuitif, il aurait mieux fallu mettre 'a' directement
    
                try {
                    sacMot = this.fils[index] // le this est inutile
                            .Recherche(mot, s.substring(i + 1, s.length()), prof + 1 + i, sacMot); // simplifiable (un peu)
                    sacMot = this.TestListe(sacMot);
                } catch (NullPointerException npe) { // grosse faute, il vaut mieux tester le cas == null plutôt que de gérer ça avec un catch
                    sacMot = this.TestListe(sacMot); // si le catch a le même résultat que le this alors autant sortir les deux
                }
            }
        }
        return sacMot;
    }

    Et voici un code après correction des commentaires, normalement ça fait la même chose :

    public List<String> recherche(String mot, String s, int prof, List<String> sacMot) {
        if (prof == mot.length())
            return testListe(sacMot);
    
        for (int i = 0; i < s.length(); i++) {
            int index = s.charAt(i) - 'a';
    
            if (fils[index] != null) {
                String s2 = s.substring(i + 1, s.length());
                int prof2 = prof + i + 1;
                sacMot = fils[index].recherche(mot, s2, prof2, sacMot);
            }
    
            sacMot = testListe(sacMot);
        }
    
        return sacMot;
    }
    1. le fais des études par correspondance et on me demande de comprendre ce truc. prof je pense que c'est la profondeur du noeud