Comment trier des cartes, tri d'array

Version imprimable

Bonjour les Developpezeurs, Voici mon tout premier post :D
J'ai commencé Java il y a une semaine ( ou peut etre deux...), j'ai appris le C/C++ quand j'étais plus jeune, puis jai eu la chance de retomber dessus en cours et donc je connais (un peu) la programmation (je m etais arrêté aux fonctions).

Je me suis lancé dans Java et apres plusieurs exercices j'ai eu envi de faire quelque chose d'un peu personnel.
Un jeu a boire :

Donc le concept est repris d'un jeu de carte, vous tirez chacun votre tour une carte et celle-ci correspond à un acte à faire ou un truc à boire enfin ca on s'en fiche.

Je ne suis pas encore bon en POO donc ce que je vais demander c'est:
- Est-ce que je m'y prend bien (ma création de classe est elle bonne) ?
- Ma methode de tri est elle bonne (j'en doute) ?
- J'ai un problème avec le return d'array dans une fonction et l'utilisation de cet array retourné pour une autre fonction.

STRUCTURE :
drinkgame (Main)
Cartes (class)

drinkgame : s'occupe de lancer Cartes et de faire passer les tours
Cartes : s'occupe d'initialiser un tas de carte (array) de le trier et de le basculer dans un autre array (est ce une bonne idée?)
Cartes aura egalement une fonction piocherUneCarte pour chaque tours.

CODE :
Donc moin Main :
Celui-ci n'est pas fini mais je pense qu'il appelera juste ma class carte pour l'initialiser et ensuite piocher des cartes
Etant aussi peu utile... est ce vraiment interressant de faire une class Carte ou ne devrais je pas plutot tout mettre dans le main ?

drinkgame MAIN :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 import java.util.Scanner; public class drinkgame { public static void main(String[] args) { int numOfCard = 30; // nombre de carte 30 Pour tester int i,y; // en cas de besoin pour les boucles :) Scanner sc = new Scanner(System.in); String reponse = new String(); Cartes cards = new Cartes(numOfCard); // on creer un packet for (i = 0; i < numOfCard ; i++) { piocherUneCarte(carte[i]); // on pioche une carte ************************** Est ce une bonne facon de faire ? ********************** System.out.println("Voulez vous repiocher une carte ? Entrer" ) reponse = sc.nextline(); } }
Classe Cartes :
Code:

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 public class Cartes { public int numOfCard; // Valeur d initiation des cartes public int i =0; //****************************************** CONSTRUCTEUR ************************************************************** public Cartes(int numOfCard){ this.numOfCard = numOfCard; this.inititPacket(); // JE NE SUIS PAS DU TOUT SURE DE trierCartes(carte); // CES DEUX LIGNES Là } // ***************************************** INITIALISATION DU PACKET ************************************************** public int[] inititPacket(){ int carte[] = {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}; // J'ai fais ce pacquet juste pour exemple je voulais voir si mon code tirait deux fois la meme carte return carte; } // ***************************************** TRIAGE DU PACKET ********************************************************** public int[] trierCartes(int[] carte){ // QUE PENSEZ VOUS DE CETTE LIGNE ? boolean tirage[] = new boolean[numOfCard]; int carteTrie[] = new int[numOfCard]; Random rn = new Random(); for(i=0; i < numOfCard ; i++){ // LE PB DE CE FOR c'est que il ne tombera pas sur toutes les cartes et il reste donc des cases vide dans mon packettrier... int aleatoir = rn.nextInt(numOfCard); if (tirage[aleatoir]) { System.out.println(carte[aleatoir]); // test pour visionner (A SUPPRIMER QUAND PROGRAMME FINI) tirage[aleatoir]=false; carteTrie[i] = carte[aleatoir]; // NOUVEAU TAS TRIER } } for(int z = 0; z < carteTrie.length ; z++){ // AFFICHER LE TAS (A SUPPRIMER QUAND PROGRAMMME FINI) System.out.print(carteTrie[z] +","); } return carteTrie; // On retourne la packet trier } // ********************************************** PIOCHER UNE CARTE ********************************************* public int piocherUneCarte(int[] carte){ return null; // PAS ENCORE FAIT } // FIN }
Bon il n'y a pas de caractere d'urgence donc si quelqu'un a le temps de jeter un oeil, un grand merci. J'espere avoir posté au bon endroit. J'ai cherché sur plusieurs sites comment faire et j'ai fini par me dire que finalement je devrais trouver la réponse, je pense avoir une bonne piste mais je pense qu'il suffit d'un petit quelque chose pour débloquer mon triage.

Puis pour la structure de mon programme, je débute la POO donc si vous pouviez me conseiller...

Merci les developpezeurs ;)

Salut,

Alors je vais prendre un a un les petits problèmes que je vois comme ça me vient à l'esprit, donc pas forcément dans l'ordre.

Tout d'abord la déclaration de tes variables int i et y. Pas besoin de les déclarer si tu as besoin d'une variable pour une boucle for fait comme ceci :
Code:

1 2 for(int i=0; i < numcard; i++) {}
Tu as le droit de déclarer ta variable dans le for, celle-ci ne sera disponible que pendant la boucle, et donc si tu as un autre for il faudra la re déclarer. Comme ça pas besoin d'avoir au début de chaque programme la déclaration de 36000 variables pour les boucles.

Ensuite concernant la POO, personnellement j'aurais plutôt vu quelque chose comme ceci :

-Une classe Carte dans laquelle il y a un constructeur Carte avec son numéro et sa couleur.
-Une classe PaquetCarte qui est une classe composé de carte, donc un constructeur avec un tableau ou une liste de carte. (Je pense qu'une liste serait mieux ici).
-Et ta classe DrinkGame qui sera ton main.

Ce qui nous donnerait quelque chose comme ceci :

class Carte
Code:

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 public class Carte { private int numOfCard; //Valeur allant de 1 à 13 (11, 12, 13 = valet, dame, roi) private int color; //Oui un int pour la couleur (allant de 1 à 4, 1=coeur, 2=pique, 3=carreau, 4=trefle, par exemple) //int car plus rapide à tester qu'un String, il faut juste bien écrire dans les commentaires quoi correspond à quoi public Carte(int numOfCard, int color) { this.setNumOfCard(numOfCard); this.setColor(color); } public int getNumOfCard() { return numOfCard; } public void setNumOfCard(int numOfCard) { this.numOfCard = numOfCard; } public int getColor() { return color; } public void setColor(int color) { this.color = color; } }
Tu remarqueras que j'ai privilégié des private plutôt que public, je fais cela pour contrôler l'accès à mes variables.

class PaquetCarte :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 import java.util.ArrayList; public class PaquetCarte { public ArrayList <Carte> carte = new ArrayList <Carte>(); public PaquetCarte(ArrayList <Carte> carte) { this.carte = carte; } //Après tu peux créer des fonction comme ajouterCartePaquet, retirerCartePaquet, creerPaquet30Carte, creerPaquet54Carte //Enfin ce que tu veux qui agit sur le paquet }
ta class DrinkGame :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 import java.util.ArrayList; public class DrinkGame { public static void main(String[] args) { // TODO Auto-generated method stub ArrayList <Carte> paquet = new ArrayList <Carte>(); PaquetCarte paquetCarte = new PaquetCarte(paquet); /*Bon après ici tu fais ce que tu veux * Tu peux utiliser les fonctions que tu auras créer dans ta classe sur ton paquetCarte * Comme par exemple si tu as crer une fonction qui met 54 cartes dans ton paquet tu n'auras qu'à appeler cette fonction en faisant * paquetCarte.NomDeLaFonction(); * Et ton paquet aura 54cartes * Après tu peux créer fonction piocher une carte enfin tout ce que tu veux*/ } }
Voilà j'ai mis des commentaires pour t'aider un peu, mais en gros toutes tes fonctions doivent se trouver dans la classe PaquetCarte. C'est pareil pour le trie des cartes, il faut créer une fonction dans la classe PaquetCarte dans laquelle tu envoies une liste et elle te renvoie une liste trié (le tri sera facilité par l'utilisation des list, des fonctions existes il me semble).

Je ne sais pas si je suis très clair dans mes explications, si jamais tu as une question n'hésite pas, et puis n'oublie pas que c'est une façon de faire, il peut y en avoir d'autre ;)

Salut,

A noter que pour mélanger les cartes (parce que vu ta fonction de tri, il semblerait qu'il s'agit plus de les mélanger), tu peux utiliser directement la méthode utilitaire Collections.shuffle(taliste).

Par contre, pour les couleurs, j'aurais utilisé plutôt une enum (ça évite déjà d'avoir à mettre des commentaires pour dire que 1 c'est cela, 2 c'est ceci...et ça évite d'avoir à se souvenir (parce que ces commentaires, on va pas les mettre partout)) :
Code:

1 2 3 4 5 6 public enum Couleur { PIQUE, COEUR, TREFLE, CARREAU }
et

Code:

private Couleur couleur;

Pour initialiser le jeu de carte :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public List<Carte> creerPaquetDeCarteMelangees() { List<Carte> cartes = new ArrayList<>(); for(Couleur couleur : Couleur.values()) { for(int i=0; i<MAX_VALEUR_DE_CARTE; i++) { cartes.add( new Carte( i, couleur) ); } } Collections.shuffle(cartes); return cartes; }
A noter, qu'il vaut mieux manipuler un List<Carte>, même si on l'initialise par un ArrayList<> : ceci permet ensuite, de ne plus s'attacher à son implémentation concrète, mais uniquement aux méthodes qui nous intéressent, celles de liste. Par la suite, on peut changer ArrayList par un autre type de List, qu'on pourrait trouver plus adapté, sans tout changer dans le code, y compris à un endroit particulier du code (par exemple, par la classe Stack, qui pourrait être utilisée pour simuler un tas dans lequel on pioche, par sa méthode pop()).

Bonjour et merci :)

Helloo merci pour les infos :D !

J'ai bien suivi vos indications, par contre je n'ai pas encore vu les énumérations alors je ne vais pas les utiliser.

J'ai bien fais 2 classes, une pour les cartes et une pour les paquets et j'ai bien compris pourquoi et l'idée.
j'ai mis la fonction creerPaquetDeCarteMelangee(); dans la class PaquetCarte

Collections.shuffle(cartes);
return cartes;
}

Ma question est, comment je récuperes le "return cartes;" dans mon main.
J'ai essayé ca:
Code:

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 public class drinkgame { public static void main(String[] args) { int numOfCard = 54; ArrayList <Cartes> paquet = new ArrayList <Cartes>(); PaquetCartes paquetCarte = new PaquetCartes(paquet); paquetCarte.creerPaquetDeCarteMelangees(); for(int y =1; y <= 4; y++) { for(int i=0; i< 54; i++) { System.out.printlnt(cartes[i][y]); // Afficher mon joli paquet } } } } }
mais eclipse me dit que je dois déclarer la variable cartes.
j'ai essayé paquetCarte.cartes[i][y] et PaquetCartes.cartes[i][y]; ....

PS: Merci pour l'astuce du INT dans la boucle.

Si tu utilises une ArrayList pour modéliser un paquets de cartes, tu ne peux plus y accèder comme un tableau à 2 dimensions comme tu fais dans System.out.printlnt(cartes[i][y]);. On pourrait convertir la liste en tableau, mais la liste est plus simple pour gérer un paquet de cartes, en particulier, si tu vas en enlever du paquet.

Pour accéder à un élément de List, on utilise la méthode get(index) au lieu de tableau[index].

Par contre, je ne vois pas pourquoi tu as un tableau à 2 dimensions, dont l'une fait 54 de longueur : tu as 4 jeux de 54 cartes à afficher ?

Ensuite pour récupérer le résultat de creerPaquetDeCarteMelangees(), il suffit d'écrire :

Code:

ArrayList<Cartes> cartes = paquet.creerPaquetDeCarteMelangees();

D'autre part, l'idée de la classe de @maelstrom, était, je suppose de construire la liste des cartes en dehors de la classe puis de la passer au constructeur de la classe :

Code:

1
2
3
4
5
6
7
List<Cartes> cartes = new ArrayList<Cartes>();
 
for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
    for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
        cartes.add( new Carte(valeur, couleur) );
    }
}

Attention, ceci donne un jeu de 52 cartes. Pour avoir 54, il faudrait ajouter 2 jokers, qui n'ont pas vraiment de couleur : mais tu peux utiliser la couleur 5 pour te simplifier la chose, mais ce n'est pas forcément le plus simple à gérer ensuite (pour associer une image par exemple) :

Code:

1
2
3
 
cartes.add( new Carte(0, 5) ); // ajoute un joker
cartes.add( new Carte(1, 5) ); // ajoute un second joker

Si ta classe Paquet n'a pour but que d'avoir la méthode createPaquetDeCarteMelangees(), elle ne sert pas à grand chose : autant la supprimer, et mélanger directement les cartes après les avoir créées :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
List<Cartes> cartes = new ArrayList<Cartes>();
 
for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
    for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
        cartes.add( new Carte(valeur, couleur) );
    }
}
cartes.add( new Carte(0, 5) ); // ajoute un joker
cartes.add( new Carte(1, 5) ); // ajoute un second joker
 
// avant l'ordre des cartes correspond à leur ordre de création, donc 14 cartes de couleur 0, suivis de 14 cartes de couleur 1, etc.
Collections.shuffle(cartes);
// maintenant les cartes sont mélangées
 
// on peut pour les afficher, par exemple faire :
 
for(Carte carte : cartes) { // signifie parcourir toute la liste de cartes, et pour chaque carte avoir une variable "carte" de type Carte.
 
   System.out.println(carte); // on affiche la carte
 
}

Si tu désires conserver la classe Paquet, pour lui ajouter des méthodes, du type piocherUneCarte() par exemple, autant mettre directement le code de création dans son constructeur :

Code:

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
public class Paquet {
 
     private List<Carte> cartes;
 
    public Paquet() {
         cartes = new ArrayList<Cartes>();
 
         for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
             for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
                cartes.add( new Carte(valeur, couleur) );
             }
         }
         cartes.add( new Carte(0, 5) ); // ajoute un joker
          cartes.add( new Carte(1, 5) ); // ajoute un second joker
    }
 
    public List<Carte> getCartes() {
         return cartes;
    }
 
     public void melanger() {
         Collections.shuffle(cartes);
     }
 
     public int getTailleDuJeu() {
         return nombre;
     }
 
     public int getNombreDeCarteDansLePaquet() {
         return cartes.size();
     }
 
     public boolean estVide() {
          return cartes.isEmpty();
     }
 
     public Carte piocher() {
          if ( cartes.isEmpty() ) { // si cartes est vide
              throw new NoSuchElementException("Plus de cartes disponible");
          }
          return cartes.remove(0); // on retire la première et on la retourne à l'appelant
     }
 
}

Et pour l'appeler :

Code:

1
2
3
4
5
6
7
8
9
10
Paquet paquet = new Paquet();
paquet.melanger();
List<Carte> cartes = paquet.getCartes();
// ou :
Carte carte = paquet.piocher();
// ou :
while( !paquet.isEmpty() ) {
    Carte pioche = paquet.piocher();
    ...
}

Avec cette classe, tu peux par exemple envisager une variante comme ça :

Code:

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
public class Paquet {
 
    private int nombre;
    private List<Carte> cartes;
 
    public Paquet(int nombre) {
        if (nombre==54 || nombre==52 ) {
           this.nombre=nombre;
           creer();
        }
        else {
           throw new IllegalArgumentException("Je ne sais gérer que des jeux de 52 ou 54 cartes");
        }
    }
 
    // recréer un jeu tout neuf, pas mélangé
    public void creer() { 
 
         cartes = new ArrayList<Cartes>();
 
         for(int couleur=0; couleur<4; couleur++) { // pour chaque couleur
             for( int valeur=0; valeur<14; valeur++ ) { // pour chaque valeur
                cartes.add( new Carte(valeur, couleur) );
             }
         }
         if ( nombre==54 ) {
            cartes.add( new Carte(0, 5) ); // ajoute un joker
            cartes.add( new Carte(1, 5) ); // ajoute un second joker
         }
 
    }
 
    public List<Carte> getCartes() { 
         return cartes;
    }
 
     public void melanger() {
         Collections.shuffle(cartes);
     }
 
}

11/12/2014, 10h16
Kanran77

Merciii

Merci pour toutes ces infos, je vais me mettre au boulot :p
:)