Discussion :

[Invité]

Bonjour
Ca fait déjà un moment que je suis sur cet bête méthode mais pas moyen je cale complètement.

Je voudrais incrémenter deux compteur, en fonction du nombre d'éléments semblable.
Puis prendre l'élément le plus fréquents (ou les plus fréquents si ils tombent sur un ex aequo)
Mes listes sont déjà trier alphabétiquement.
L'une est sans les doublons pour la comparaison.

Entre les erreurs de compilation et les résultat non souhaiter je désespère.

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
80
81
82
public class StatisticsTest {
 
    public static void main(String[] args) {
 
    		HashSet<String> Set = new HashSet<String>();
    	    ArrayList<String> color = new ArrayList<String>();
    	    ArrayList<String> listSet = new ArrayList<String>();
    	    ArrayList<String> top = new ArrayList<String>();
 
 
            color.add("Rouge"); //5Rouge
            color.add("Rouge");//6Bleu
            color.add("Rouge");//3Vert
            color.add("Vert");//2Jaune
            color.add("Bleu");
            color.add("Bleu");
            color.add("Bleu");
            color.add("Bleu");
            color.add("Jaune");
            color.add("Vert");
            color.add("Vert");
            color.add("Rouge");
            color.add("Rouge");
            color.add("Jaune");
            color.add("Bleu");
            color.add("Bleu");
 
            Set.addAll(color);
            listSet.addAll(Set);//On efface les doublons et on les remets sous forme de liste
 
            Collections.sort(listSet);
            Collections.sort(color);
 
            int topCompteur=0;
            int nouveau =0;
            int compteur = 0;
 
 
 
 
            for(int i=0; i<listSet.size();i++){ 										
               String suivant = listSet.get(++i);
                  if ((i%2)== 1){
 
                	  for(int j=0; j< color.size(); j++){	
 
                		  boolean egalite = color.get(j).equals(listSet.get(i));
 
 
                		  if(egalite == false){ 										
                			  nouveau++;																
 
                			  boolean condition2 = color.get(j).equals(suivant); 				
 
                			  if(condition2 == false)											
                			  	{break;}
                		  }
                		  if(color.get(j).equals((listSet.get(++i))))
                			  if(egalite == true){ 													
                				  compteur++;
                			  }      			
                	  }
 
               	if (topCompteur==nouveau || topCompteur==compteur)
            				{top.add(listSet.get(i));}
            	if (topCompteur<nouveau || topCompteur<compteur){
           	      	if (nouveau < compteur)
           	      		topCompteur = compteur;
           	      	else
           	      	{topCompteur = nouveau;}
    				top.clear();
       				top.add(listSet.get(i));
 
            	}         			
 
            	 } 
 
            }               
           System.out.println(top);         
    }
 
}

[rolfone]

bon si je ne me trompe pas c'est un double post comme il te la était dit dans l'autre post il te faut un Comparator qui doit évaluer la valeur de chaque String

alors voila un exemple ( un peut plus qu'un exemple même c'est la solution) qui ne prend pas en compte les ex aequo mais la il faut bien que tu réfléchisse un peur

la class main

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
public class StatisticsTest {
 
    public static void main(String[] args) {
 
        ArrayList<String> color = new ArrayList<String>();
        //5 Rouge; 6 Bleu; 3 Vert; 2 Jaune
        color.add("Rouge");
        color.add("Rouge");
        color.add("Rouge");
        color.add("Vert");
        color.add("Bleu");
        color.add("Bleu");
        color.add("Bleu");
        color.add("Bleu");
        color.add("Jaune");
        color.add("Vert");
        color.add("Vert");
        color.add("Rouge");
        color.add("Rouge");
        color.add("Jaune");
        color.add("Bleu");
        color.add("Bleu");
 
        Collections.sort(color, new CouleurComp(color));
 
        for(String s : color){
            System.out.println(s);
        }
 
    }
}

la class Comparator

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
public class CouleurComp implements Comparator<String> {
 
    Map<String, Integer> poidValeurs = null;
 
    public CouleurComp(Map<String, Integer> poidValeurs) {
        this.poidValeurs = poidValeurs;
    }
 
    public CouleurComp(List<String> Valeurs) {
        this.poidValeurs = new HashMap<String, Integer>();
        Set<String> set = new HashSet<String>();
        // on compte le nombre de chaque couleur
        for (String s : Valeurs) {
            if (set.add(s)) {
                poidValeurs.put(s, new Integer(1));
            } else {
                poidValeurs.put(s, poidValeurs.get(s) + 1);
            }
        }
 
        System.out.println(poidValeurs);
    }
 
    public int compare(String o1, String o2) {
        return poidValeurs.get(o2) - poidValeurs.get(o1);
    }
}

le output

{Bleu=6, Vert=3, Jaune=2, Rouge=6}
Bleu
Bleu
Bleu
Bleu
Bleu
Bleu
Rouge
Rouge
Rouge
Rouge
Rouge
Rouge
Vert
Vert
Vert
Jaune
Jaune

[Invité]

C 'est très gentil rolfone, seulement je suis un peu perdu.
J'ai pas l'habitude de travaillé avec les Map, et encore moins avec les comparators.(débutant oblige ;-) )
Puis je dois avoir ça dans la même classe :-/
Je me doute que pour trouvé l'ex aequo, je dois trier la map par valeurs et tester de chacune des valeurs.

Puis mon but est simplement de faire apparaitre la(les) clés qui a la valeur(s) la plus élevé. Sans faire apparaitre la valeur.

Excuse moi du double post, mais c'est que d'une part je suis un peu presser, que j'ai essayé beaucoup par moi même et qu'au final mon code de l'ancien post changeais beaucoup par rapport a la situation initiale.

[rolfone]

tu a juste besoin de connaitre le count de chaque valeur est les classé en fonction de cette valeur ?

en fait tu veut juste la 1er ligne de mon output mais classé ?

[Invité]

Oui , enfait même moins,
Dans ton output (d'exemple-solution) je veux simplement, rouge et Bleu car il y a un cas d'ex aequo (6 chacun)

Imaginons le cas où il y a que 5 rouge, alors j'aimerais avoir un output qui dit :

Bleu

Je sais que c'est pas très sorcier mais malheureusement, je peine depuis plus d'une semaine, (la actuelement j'essaye avec des double tableaux)

[rolfone]

Puis je dois avoir ça dans la même classe :-/

cette condition t'est imposé pour quel raison ?

[Invité]

C'est les directive du professeur, et je suppose que c'est parce qu'il y a des class test qui nous permettent de voir si les résultat obtenu sont correcte.

[rolfone]

dit moi si c'est un exercice les restrictions que tu a.

par exemple peut tu utiliser les Map ?

[Invité]

Oui j'ai le droit d'utilisé les map, set, list.
de créer des nouvelle méthode.
La seul chose défendue est la création de nouvelle classe et l'utilisation d'un code qu'on ne sait pas expliqué.

[rolfone]

voila un idée

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
public class Couleur {
    // la couleur que l'on a trouver
    private String couleur;
    // le nombre de foix que cette couleur est trouver dans la liste d'origine
    private int count = 1;
 
    public Couleur(String couleur) {
        this.couleur = couleur;
    }
 
    public String getCouleur() {
        return couleur;
    }
 
    public int getCount() {
        return count;
    }
 
    public void increment() {
        this.count++;
    }
 
    public static void main(String[] args) {
 
        // on initialise la liste des couleurs
        ArrayList<String> color = new ArrayList<String>();
        //5 Rouge; 6 Bleu; 3 Vert; 2 Jaune
        color.add("Rouge");
        color.add("Rouge");
        color.add("Rouge");
        color.add("Vert");
        color.add("Bleu");
        color.add("Bleu");
        color.add("Bleu");
        color.add("Bleu");
        color.add("Jaune");
        color.add("Vert");
        color.add("Vert");
        color.add("Rouge");
        color.add("Rouge");
        color.add("Jaune");
        color.add("Bleu");
        color.add("Bleu");
 
        // on recupere la liste des couleurs (on utilise notre class pour porté le nom de la couleur mais
        // aussi son nombre d'aparition dans le liste source)
        Set<Couleur> couleurs = new HashSet<Couleur>();
        for (String couleur : color) {
            Couleur newColor = new Couleur(couleur);
            couleurs.add(newColor);
        }
 
        // pour chaque couleur different on compte le nombre d'appartition
        for (Couleur c : couleurs) {
 
            for (String s : color) {
                if (c.getCouleur().equalsIgnoreCase(s)) {
                    c.increment();
                }
            }
        }
 
        // on vas cherché la couleur qui a le plus grand count
        Couleur couleurMax = new Couleur("first");
        for (Couleur c : couleurs) {
            if (c.getCount() > couleurMax.getCount()) {
                couleurMax = c;
            }
        }
 
        System.out.println(couleurMax);
    }
 
    @Override
    public String toString() {
        return this.getCouleur();
    }
}

je pense que c'est un truc dans ce style que ton prof vas attendre par contre utilise pas directement ce que j'ai fait c'est pas forcement le plus judicieux

utilise bien les règle de programmation de ton prof

a oui et je ne gère pas les ex aequo mais tu doit pouvoir trouvé par toi même la

ton problème c'est qu'il te faut porté 2 information en même temps le nom de la couleur et sont nombre d'apparition après c'est de l'affichage

par contre selon le sujet de ton exo ton prof veut peut etre que t'a class implement List ou autre (ca c'est a toi de voir en fonction de ce que tu vois avec lui en ce moment)

[rolfone]

tien j'en est meme une plus simple sans les ex-equo mais sa c'est a toi de voir apres

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
public class Couleur {
    public static void main(String[] args) {
 
        // on initialise la liste des couleurs
        ArrayList<String> color = new ArrayList<String>();
        //5 Rouge; 6 Bleu; 3 Vert; 2 Jaune
        color.add("Rouge");......
 
        Set<String> couleurs = new HashSet<String>(color);
 
        String couleurMax = null ;
        int coutMax =0;
        int count = 0;
 
        for(String curentColor : couleurs){
            for(String s : color){
                if(s.equalsIgnoreCase(curentColor)){
                    count++;
                }
            }
 
            if(count > coutMax){
                couleurMax = curentColor;
                coutMax= count;
            }
            count = 0;
        }
        System.out.println(couleurMax);
 
    }
}

[Invité]

Merci J'ai su implémenter pour les ex-aequo.
Il faut avouer que tu m'as maché le travaille.
Merci quand même.

[rolfone]

oui même peut être un peut trop mâché le travaille mais je pense que tu était partie loin de la solution et quand on commence à ce perdre c'est beaucoup plus dure de revenir à des solutions simple

car le problème n'était pas très compliqué en sois peut tu juste me dire sur laquelle des 2 solutions que j'ai donné tu est partie ?

[Invité]

Sur la deuxième et j'ai utilisé la deuxième car elle a une boucle en moins et moins de méthode.

Pour l'ex-aequo, j'ai remplacé le String couleurMax par une liste.
et j'ai rajouté une condition d'égalité ainsi que rajouté une instruction couleurMax.clear(); dans la condition de supériorité des compteur.

Depuis ça fonctionne très bien ;-)