Discussion :

[bibim]

Bonjour,
je suis entrain d'écrire un script me permettant d'évaluer les amins au poker et me heurte au problème suivant: j'ai besoin de classer un tableau(en variables de type byte) à deux dimmensions comme suit:
Au départ j'ai

Code :

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

 byte [][] cards={{2,9,11,3,14,5,5},{3,1,1,1,1,0,3}};

Pour les curieux, les première donées sont la valeur des cartes (variant de 2 à 14) et la les deuxièmes données sont les valeurs des familles (variant de 0 à 3)
et j'aimerais finir avec le tableau suivant

Code :

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

 byte [][] cardsSorted={{2,3,5,5,9,11,14},{3,1,0,3,1,1,1}};

J'ai trouvé une solution (fastudieuse) sur le web qui est la suivante

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
 
import java.util.Arrays;
import java.util.Comparator;
 
public class storing {
 
	/**
         * @param args
         */
	public static void main(String[] args) {
 
		byte [][]number={{4,6,2,3,7,8,1},{8,9,1,3,2,5,6}};
		String [][]numbers=new String[][]{
				{String.valueOf(number[0][0]),String.valueOf(number[1][0])},
				{String.valueOf(number[0][1]),String.valueOf(number[1][1])},
				{String.valueOf(number[0][2]),String.valueOf(number[1][2])},
				{String.valueOf(number[0][3]),String.valueOf(number[1][3])},
				{String.valueOf(number[0][4]),String.valueOf(number[1][4])},
				{String.valueOf(number[0][5]),String.valueOf(number[1][5])},
				{String.valueOf(number[0][6]),String.valueOf(number[1][6])},
 
 
		};
 
 
		Arrays.sort(numbers, new Comparator<String[]>() {
		    @Override
		    public int compare(String[] s1, String[] s2) {
		        String t1 = s1[0];
		        String t2 = s2[0];
		        return t1.compareTo(t2);
		    }
		});
 
byte [][]sortedNumbers=new byte[][]{
		{(byte) Integer.parseInt(numbers[0][0]),(byte) Integer.parseInt(numbers[0][1])},
		{(byte) Integer.parseInt(numbers[1][0]),(byte) Integer.parseInt(numbers[1][1])},
		{(byte) Integer.parseInt(numbers[2][0]),(byte) Integer.parseInt(numbers[2][1])},
		{(byte) Integer.parseInt(numbers[3][0]),(byte) Integer.parseInt(numbers[3][1])},
		{(byte) Integer.parseInt(numbers[4][0]),(byte) Integer.parseInt(numbers[4][1])},
		{(byte) Integer.parseInt(numbers[5][0]),(byte) Integer.parseInt(numbers[5][1])},
		{(byte) Integer.parseInt(numbers[6][0]),(byte) Integer.parseInt(numbers[6][1])},
};
 
//s'occupe d'afficher les résultats
		for(int i=0;i<7;i++){
		System.out.print(sortedNumbers[i][0]);
		System.out.print("   "+sortedNumbers[i][1]);
		System.out.println(" ");
		}
}
}

Maintenant mais question est: peut-on se passer de toutes ces conversions et/ou existe-t-il des méthodes déjà incluses dans Java pour me faciliter la tâche?

J'ai trouvé quelques tutoriels concernant les "compare" et "comparator" mais je n'y ai pas compris grand chose, si quelqu'un a le temps pour m'expliquer le fonctionnnement (de préférence avec un berf exemple) sa serait avec grand plaisir.

Merci d'avance pour vos réponses.

[LittleBean]

Bonjour,
Si tu travailles avec byte nul besoin de comparator;

ex :

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
	public static void main(String[] args) {
 
		byte[][] number = { { 4, 6, 2, 3, 7, 8, 1 }, { 8, 9, 1, 3, 2, 5, 6 } };
		for (int i = 0; i < 7; i++) {
			System.out.print(number[0][i]);
			System.out.print("   " + number[1][i]);
			System.out.println(" ");
		}
		Arrays.sort(number[0]);
		System.out.println("-------------------------------");
		Arrays.sort(number[1]);
		for (int i = 0; i < 7; i++) {
			System.out.print(number[0][i]);
			System.out.print("   " + number[1][i]);
			System.out.println(" ");
		}
	}

Par contre je penses que ton problème vient du mauvais choix de structure :

En quoi

Code :

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

byte[][] number = { { 4, 6, 2, 3, 7, 8, 1 }, { 8, 9, 1, 3, 2, 5, 6 }

représente une main ?

J'aurais plus vu :

Code :

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

byte[][] number = { { 4, 6}, {2, 3}, { 7, 8} ... }

Une carte est une paire de byte non ?
du coup tu as un comparator comme ça

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Comparator;
 
public class CompByte implements Comparator<Byte[]> {
	@Override
	public int compare(Byte[] o1, Byte[] o2) {
		int compareTo = o1[0].compareTo(o2[0]);
		if (compareTo == 0){
			return o1[1].compareTo(o2[1]);
		}
		return compareTo;
	}
}

Attention tout ça marche mais n'est pas bon au sens POO.

Tu devrais créer une classe Carte, 2 enum NOMBRE et COULEUR, une classe CarteComparator ...


Bon courage

[bibim]

Re-bonjour,
Tout d'abord quelques explications sur ce que je recherche car malheureusement la solution proposée n'est pas la bonne

Je désire classer ma permière colonne et que les éléments de la deuxième colone restent "fidèles" à leurs éléments en première colone. Tout simplement trier une fois chaque colone met du désordre dans mes cartes puisque la carte avec la valeur 4 et de famille 1 ne se retrouvera pas forcément avec la famille 1 à la fin du tri.

Code :

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

1
2
 
 byte [][] cards={{2,9,11,3,14,5,5},{3,1,1,1,1,0,3}};

donne

Code :

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

1
2
 
 byte [][] cardsSorted={{2,3,5,5,9,11,14},{3,1,0,3,1,1,1}};

vous remarquerz que 2 ->3; 3 ->1 etc. La place des deuxièmes éléments par rapport au premiers est importante.

N.B je crée un "hold'em" donc 7 cartes avec leur familles en deuxième colone, si il n'y a pas 5 fois le même élément dans la deuxième colone je m'en débarasse et ne regarde que les valeurs des cartes puisque tout type de "flush" est impossible et la famiille des cartes n'est plus d'aucune importance....

Par ailleurs, bien sur que mon programme est orientée poo. J'ai un total de 7 classes différents dont bien sur une classe de cartes, un classe évaluateur, une classe affichage des cartes, une autre affichage des resultats etc... si vous êtes intéressés je peux vous mettre le code tout entier à disposition

[adiGuba]

Salut,

Par ailleurs, bien sur que mon programme est orientée poo.

Dans ce cas pourquoi tu utilises un tableau de bytes à deux dimensions pour représenter ton jeu ????


Un liste d'objet "Carte" comprenant deux attributs "valeur" et "couleur" serait bien plus souple à gérer...


a++

[LittleBean]

Dans ce cas pourquoi tu utilises un tableau de bytes à deux dimensions pour représenter ton jeu ????

Un liste d'objet "Carte" comprenant deux attributs "valeur" et "couleur" serait bien plus souple à gérer...

Voila c'est ce que j'essaie de te dire


Même en passant par un tableau tu as un problème de structure :
ton numéro et ta couleur ne sont pas liés!
Voila un exemple rapide en passant par une paire de Byte

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
import java.util.Arrays;
import java.util.Comparator;
 
 
public class Main {
	public static void main(String[] args) {
		 byte [][] initCards={{2,9,11,3,14,5,5},{3,1,1,1,1,0,3}};
		 // crée des "cartes" => des paires
		 Byte [][] realCards= new Byte [7][2];
			for (int i = 0; i < 7; i++) {
				realCards[i][0] = initCards[0][i];
				realCards[i][1] = initCards[1][i];
			}
			// on les tris par numéros
			Arrays.sort(realCards, new CompByte());
			// on les remets sous la forme premiére
			 byte [][] resultCards= new byte [2][7];
				for (int i = 0; i < 7; i++) {
					resultCards[0][i] = realCards[i][0];
					resultCards[1][i] = realCards[i][1];
				}
//				for (int i = 0; i < 7; i++) {
//					System.out.print(resultCards[0][i]);
//					System.out.print("   " + resultCards[1][i]);
//					System.out.println(" ");
//				}
		 byte [][] expectedCards={{2,3,5,5,9,11,14},{3,1,0,3,1,1,1}};
		 boolean equals = Arrays.deepEquals(expectedCards, resultCards);
		 System.out.println(equals);
	}
}
 
class CompByte implements Comparator<Byte[]> {
	@Override
	public int compare(Byte[] o1, Byte[] o2) {
		return o1[0].compareTo(o2[0]);
	}
}