Discussion :

[sinzen]

Bonjour,

J'ai implementer un algorithme de compteur d'anagrammes.

Je l'ai fait avec Java mais je me rend compte que mon code n'est du tout évolutif.

Et j'ai beaucoup de code pour chaque sequences de traitement..

je voudrait savoir s'il est possible de rendre le code plus évolutif et moins conséquent ?

il y a aussi beaucoup de redondance etc..

le but de ce code est de detecter les possible anagrammes dans une chaine de caractère,

les chaines seul ne sont donc pas pris en compte vue leur unicité,

je fait les comparaison sur deux chaine et plus.. et fait le compte du nombre d'anagrammes,

Je sais que je peux améliorer mon code mais je voudrait vos conseils

merci pour vos réactions.

voici le code:

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
public class AnagrammesImpl {
 
    //je remplie une liste avec chaque mot de la chaine de caractères
    public List<String> anagrammesMethode(String s)
    {
        List<String> mList = new ArrayList<String>();
        String  val= "";
        for (int i=0;i< s.length();i++)
        {
            val = val + s.charAt(i);
            if (s.charAt(i) == ' ' )
            {
                mList.add(val);
                val = "";
            }
        }
        return mList;
    }
 
    //je supprime les mots unique dans la liste
    public void suppressionElementUnique(List list)
    {
        for(int i=0;i<list.size();i++)
        {
            for (int j=i+1;j<list.size();j++)
                if(list.get(i).equals(list.get(j)))
                {
                    list.removeAll(Arrays.asList(list.get(j)));
                }
        }
    }
 
    //je trie les mots par ordre alphabetique et trie chaque mot charactères par charactères
    public void trieListeEtMot(List<String> list,List listeTrier)
    {
 
        Collections.sort(list);
        for(int i=0;i<list.size();i++)
        {
            char[] c = list.get(i).trim().toCharArray();
            Arrays.sort(c);
            String sorted = new String(c);
            listeTrier.add(sorted);
        }
    }
 
    //je creer un liste et ajoute les anagrammes dans la liste
    public ArrayList listeAnagrammesChaineChar(List<String> list)
    {
        Collections.sort(list);
        ArrayList listeAnagrammes = new ArrayList() ;// int i=0;
        for(int i=0;i<list.size();i++)
        {
            for(int j=i+1;j<list.size();j++)
            {
                if(list.get(i).equals(list.get(j)))
                {
                    listeAnagrammes.add(list.get(i));
                }
            }
 
        }
        return listeAnagrammes;
    }
    //je supprime les doublon dans les anagrammes et fait le compte de mot
    public int suppressionDoublonAnagrammeEtCalcluNbAnagramme(List list)
    {
        int cpt=0;
        Set set = new HashSet() ;
        set.addAll(list) ;
        ArrayList distinctList = new ArrayList(set);
        for(int i = 0;i<distinctList.size();i++)
        {
            cpt++;
        }
        return cpt;
    }
}

[Songbird]

Salut,

Je peux t'aider sur certains points pour recycler/réorganiser des parties de ton code, voici mes remarques:

- Tu n'utilises pas assez de constantes, exemple:

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
final static int ARRAY_LENGTH = 10;
 
final static int[] array = new int[ARRAY_LENGTH];
 
for(int i = 0; i<ARRAY_LENGTH; i++)
{
    //do something
}
 
public final void foo(List list)
{
    //On ne connaît pas la taille de la liste, on la récupère
    final int LIST_SIZE = list.size();
 
    for(int i = 0; i<LIST_SIZE; i++){} //On évite les appels répétés et inutiles (et ça nous permet de récupérer rapidement la taille de la liste si on en a encore besoin par la suite)
}

L'exemple est aussi valable pour la méthode length() de la classe String.

- Lorsqu'une liste/tableau passé en paramètre n'est pas modifié, il est préférable de la/le passer en lecture seule

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public int suppressionDoublonAnagrammeEtCalcluNbAnagramme(final List list)
    {
        int cpt=0;
        Set set = new HashSet() ;
        set.addAll(list) ;
        ArrayList distinctList = new ArrayList(set);
        final int LIST_SIZE = distinctList.size();
        for(int i = 0;i<LIST_SIZE;i++)
        {
            cpt++;
        }
        return cpt;
    }

- Rendre tes identifiants plus explicites: (je prends cette méthode comme exemple, mais ça s'applique ailleurs)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public int suppressionDoublonAnagrammeEtCalcluNbAnagramme(final List list)
    {
        int compteur =0;
        Set set = new HashSet() ;
        set.addAll(list) ;
        ArrayList distinctList = new ArrayList(set);
        final int LIST_SIZE = distinctList.size();
        for(int i = 0;i<LIST_SIZE;i++)
        {
            compteur ++;
        }
        return compteur;

Pour le reste, que souhaites-tu en faire, de cette classe, par la suite ?

Effectivement toutes tes méthodes parcourent des tableaux, il peut être logique que l'utilisation d'une boucle revienne souvent.

PS: Mais ma vision est peut être trop procédurale, à toi de me dire si tu souhaites pouvoir implémenter ces méthodes dans d'autres classes ou non.

[sinzen]

Bonjour Songbird,

En premier lieu, merci pour ta réaction.

Je trouve tes remarques très constructive,
qui me permette d'avoir un vue d'ensemble

le but de ce code n'est pas de l'implementer dans un projet ou autre,

j'essai de me Driller a un quelconque entretien technique.

vu que les recruteurs font souvent passer des test technique sous elaboration d'un mini projet.

Mon avis:

je pense pour pouvoir réussir avec succès
il fait vraiment avoir une logique rigoureuse
et comprendre le cas de façon global,
poser les questions avant de commencer le projet est une bonne façon de commencer,
on ne peut avoir tous compris des le départ,
il ya toujours un cas qui nous échappe ou que nous n'avons pas prévus
avant de rentrer dans le code

pour la partie codage,
ma question est de savoir si mon approche est bien élaborer,
car il faut tout de même avoir un code évolutif au final.

si vous avez d'autres remarques je suis preneur..

merci pour vos réactions.

[Songbird]

Bonjour sinzen,

pour la partie codage,
ma question est de savoir si mon approche est bien élaborer,
car il faut tout de même avoir un code évolutif au final.

si vous avez d'autres remarques je suis preneur..

D'accord, je vois.

Alors, pour ma part, ta classe me paraît plutôt correct. Même si l'architecture de la source doit être propre, attention à ne pas essayer de recycler là où on ne peut pas.

Voilà un conseil que j'essaie d'appliquer moi-même en général:

Lorsque tu implémentes une nouvelle fonctionnalité (classe ou méthode), essaies d'avoir le réflexe de réfléchir à toutes les entrées que pourraient prendre ta méthode/classe/constructeur pour ensuite recycler ton code et éviter les répétitions, exemple:

Code Java :

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
public class Foo
{
    public Foo(String entree_1, String entree_2, String entree_3)
    {
        //On a conçu le constructeur contenant le plus d'entrées, plus qu'à développer la fonctionnalité
        /*ton code*/
    }
 
    public Foo(String entree_1, String entree_2)
    { 
        new Foo(entree_1, entree_2, "");
    }
 
    public Foo(String entree_1)
    {
 
        new Foo(entree_1, "", "");
    }
}

J'enfonce un peu des portes ouvertes avec mon exemple, mais parfois on (moi en tout cas) oublie les concepts de base qui font, à 90% du temps, bien le café en plus de nous préserver du sacro saint copier/coller. (grand pionnier des projets monolithiques)

Plus sérieusement, en surchargeant au maximum tes constructeurs et méthodes (lorsque c'est possible) tu n'auras aucun mal à faire évoluer ton code.

En espérant que mon exemple ait permis d'illustrer à peu près ce que je voulais dire.