Comment puis-je imprimer toutes les "maisons pleines" possibles au poker avec Java?

Question

Je me demandais si quelqu'un savait comment implémenter le code en java pour imprimer tous les cas de full house. Il y a environ 3700 cas différents. Jusqu'à présent, je suis autour de 2700 mais j'ai du mal à changer les costumes, elle est ce que j'ai jusqu'à présent.

public class FullHouseTest 
{// 
static int count = 1; 
static int [] cards ={1,2,3,4,5,6,7,8,9,10,11,12,13}; 
static int[] suit ={1,2,3,4}; 
static int[] suit2 ={2,3,4,1}; 
static int[] suit3 ={3,4,1,2}; 
public static void main(String[] args) 
{ 
    for(int k = 0; k< 12; k++) 
    { 
    for(int i = 0; i < 3; i++) 
    { 
    for (int t = 0; t <3; t++) 
    { 
    Card one = new Card(new Suit(suit[t]), new Pips(cards[k])); 
    Card two = new Card(new Suit(suit2[t]), new Pips(cards[k])); 
    Card three = new Card(new Suit(suit3[t]),new Pips(cards[k])); 

    for (int j =0; j < 12; j++) 
     { 
     Card four = new Card(new Suit(suit2[i]), new Pips(cards[j+1])); 
     Card five = new Card(new Suit(suit[i]), new Pips(cards[j+1])); 
     System.out.println("Hand:" + count + " | " + one + two + three + four + five); 
     count ++; 
     } 
    } 
    } 
    } 
    for(int i = 0; i < 3; i++) 
    { 
    for(int k = 0; k< 12; k++) 
    { 
    for(int s = 0; s<3; s++) 
    { 
     Card one = new Card(new Suit(suit[i]), new Pips(cards[k])); 
     Card two = new Card(new Suit(suit2[i]), new Pips(cards[k])); 
    for (int j =0; j < 12; j++) 
    { 

     Card three = new Card(new Suit(suit3[s]),new Pips(cards[j+1])); 
     Card four = new Card(new Suit(suit2[s]), new Pips(cards[j+1])); 
     Card five = new Card(new Suit(suit[s]), new Pips(cards[j+1])); 
     System.out.println("Hand:" + count + " | " + one + two + three + four + five); 
     count ++; 


    } 
    } 
    } 
    } 

} 
} 

Answer 1

Ajoutez des commentaires à votre code avant d'aller plus loin. Cela vous aidera à comprendre ce qui se passe, en particulier lorsque vous avez des boucles 4 imbriquées avec des noms de variables à caractère unique.

Ensuite, brisez le problème: Quelle est la particularité d'une maison pleine? Les deux nombres de pips sont uniques mais ne peuvent pas être identiques. Le 3 d'une sorte a 3 costumes différents (ou en manque juste un), et la paire a 2 costumes différents.

total_pips * (total_pips-1) * number_suits * (possible combinations of 2 suits) = 3744 
    13   12    4       6 

Pensez à ce que vous pourriez manquer dans cette liste. Si vous avez des questions spécifiques il suffit d'éditer la réponse et nous y arriverons :)

Answer 2

Trop de code dans une méthode principale. vous devez utiliser des méthodes mieux ici.

créer une méthode appelée isFullHouse(Card[] card), qui prend dans un tableau (ou ArrayList) de 5 cartes et déterminera pour vous si la main est un full house.

Ensuite, la manière dont vous choisissez de créer toutes les combinaisons de mains possibles dépend de vous. Chaque fois que vous obtenez une nouvelle main, appelez cette méthode. Cela simplifiera les choses pour vous. Tout dans le main est très difficile à lire.

En ce qui concerne la façon dont vous stockez votre jeu de cartes. au lieu de tous ces tableaux, en stocker un qui est 0-51. vous pouvez utiliser les opérateurs de division et de mod sur le tableau pour déterminer quelle carte vous avez. Le chiffre magique est 13.

i.e. The 47 card in the deck could be: 47/13=3 ; 47 % 13 = 8 

Si vous déterminez à l'avance que 0 = coeurs, 1 = diamants, 2 = clubs et 3 = pique, alors vous pouvez déterminer que cette carte est le 9 of spades (8 + 1 en raison de l'absence de carte ayant la valeur 0, ajoutez-en une)

Stockez toutes ces idées dans leurs propres méthodes, et vous pouvez considérablement simplifier vos boucles.

Answer 3

Rapide et sale. Il y a beaucoup de place pour l'amélioration, mais si mes calculs sont corrects, cela devrait vous donner toutes les combinaisons de mains valides d'une maison complète.

public class PrintFullHouse {

enum Suit {CLUBS, DIAMONDS, HEARTS, SPADES} 
enum Rank {Ace, One, Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King} 

public static void main(String[] args) { 

    String[] ranks = new String[14]; 
    String[] suits = new String[4]; 

    populateSuits(suits); 
    populateCards(ranks); 

    int numberOfCombos = 0; 

    //Loop over all card values. This outer for loop is for the 3 of kind values. 3 Aces, 3 Twos, 3 Threes, etc 
    for(int card = 0; card < ranks.length; card++) 
    { 
     String firstCard = ranks[card]; 

     for(int suit1 = 0; suit1 < suits.length; suit1++) 
     { 
      for(int suit2 = suit1+1; suit2 < suits.length; suit2++) 
      { 
       for(int suit3 = suit2+1; suit3 < suits.length; suit3++) 
       { 
        //Loop over all card values that aren't equal to the firstCard.So we won't have 3 Aces and 2 Aces 
        for(int card2 = 0; card2 < ranks.length; card2++) 
        { 
         String secondCard = ranks[card2]; 

         //Dont Compare the 3 of a Kind and 2 pair when they are the same rank. ie Aces and Aces 
         if(firstCard.compareTo(secondCard) != 0){ 
          for(int othersuit1 = 0; othersuit1 < suits.length; othersuit1++) 
          { 
           for(int othersuit2 = othersuit1+1; othersuit2 < suits.length; othersuit2++) 
           { 
            //Found a valid combo if 3 of a kind have different suits, 2 pair have different suits, and card1 is not equal to card2 
            numberOfCombos++; 
            System.out.println(numberOfCombos+". "+firstCard+" "+suits[suit1]+" "+firstCard+" "+suits[suit2]+" "+firstCard+" "+suits[suit3]+ " " 
                 +secondCard+" "+suits[othersuit1]+" "+secondCard+" "+suits[othersuit2]); 
           } 
          } 
         } 
        }    
       } 
      } 
     } 
    } 
} 

private static void populateSuits(String[] suits) { 

    int index = 0; 
    for(Suit suit: Suit.values()) 
    { 
     suits[index++] = suit.toString(); 
    } 
} 

private static void populateCards(String[] ranks) { 

    int index = 0; 
    for(Rank rank: Rank.values()) 
    { 
     if(index != ranks.length) 
     ranks[index++] = rank.toString(); 
    } 
} 

}

Answer 4

J'ai vu ce problème l'autre jour (alors en congé de maladie). Je discute de l'idée de sonner depuis. D'un côté, cela semble être un devoir. (C'est un problème simple, votre code est difficile à comprendre, ce qui indique un manque d'expérience.)

D'un autre côté, cela ne me dérange pas de donner un coup de main. Je ne vais pas faire votre travail pour vous, mais je peux vous diriger dans la bonne direction ...

---

Première étape: Définir le problème. Une fois clairement définies, les réponses deviennent beaucoup plus simples.

A "full house", vraisemblablement 5 cartes composées d'un trois-de-un-type plus une paire. Il s'agit vraisemblablement d'un jeu à un seul jeu. Il s'agit vraisemblablement d'un deck standard (As, 2,3,4,5,6,7,8,9, Jack, Queen, King) avec des combinaisons (Spades, Clubs, Coeurs, Diamants). (Abrégé ci-dessous sous (A23456789JQK) et (SCHD).)

Vous mentionnez 3700 combinaisons. On peut donc supposer que les mains (2S, 2C, 2H, 3H, 3D) et (3D, 3H, 2H, 2C, 2S) sont équivalentes plutôt que distinctes. (C'est en fait un point important, comme Sean & Loadmaster dans leurs commentaires Il ya 311 875 200 (52 * 51 * 50 * 49 * 48) dessins de 5 cartes possibles, mais seulement 2 598 960 de ces mains sont distinctes!)

Nous avons (13 * 4) possibles trois-de-un-genre. Par exemple. Pour chaque carte de rang (telle que 3), nous pouvons avoir 4 trois-de-un-types ({0S, 3C, 3H, 3D}, {3S, 0C, 3H, 3D}, {3S, 3C, 0H, 3D }, {3S, 3C, 3H, 0D}). (Peut-être vous commencez à remarquer un modèle: 0111 1011 1101 1110.)

Donnez à notre trois-en-un, et en supposant que c'est un jeu de plate-forme unique et de plate-forme standard, notre paire doit être l'un des 12 autres restants classements de cartes. Pour chaque rang de carte, il y a six possibilités pour une paire. Par exemple. Étant donné un rang de carte de 7, nous pourrions avoir ({7S, 7C, 0H, 0D}, {7S, 0C, 7H, 0D}, {7S, 0C, 0H, 7D}, {0S, 7C, 7H, 0D} {0S, 7C, 0H, 7D}, {0S, 0C, 7H, 7D}). (Encore une fois, vous remarquerez peut-être le modèle: 1100 1010 1001, 0110 0101, 0011.)

Cela nous donne 13 * 4 * 12 * 6 = 3744 combinaisons.

À partir de là, il suffit de faire une boucle pour les imprimer.

Je vous suggère de considérer plus de noms de variables descriptives. Bien qu'il existe des lieux et des heures pour utiliser des variables de boucle à caractère unique, cela n'en fait pas partie. Le code bien écrit est presque auto-documenté, permettant à la documentation de se concentrer sur les abstractions de plus haut niveau plus complexes. Les quelques caractères supplémentaires que vous économiserez vous coûteront une fortune en temps de débogage. Si vous le souhaitez, vous pouvez être paresseux comme moi, apprendre emacs, utiliser (require 'completion), (global-set-key "\ C - \\"' complet), taper les premiers caractères et laisser emacs auto-compléter pour vous .

Je vous suggère de prendre en charge, et peut-être privé, les méthodes. Par exemple, vous pourriez être en mesure de faire quelque chose comme: (. Cela a été un moment que je codé en Java)

for (suit = 0; suit < 4 ; ++ suit) 
    private_printThreeOfAKind(card, suit!=0, suit!=1, suit!=2, suit!=3) 

Trois d'entre eux (! =) Serait vrai, on serait faux.

En ce qui concerne les paires d'impression, vous pouvez étudier le continuer l'instruction. Réf.: http://en.wikipedia.org/wiki/Java_syntax#continue_statement

E.g. Cela vous permet de sauter dans le cas où la carte paire est le même rang que les trois-of-a-kind:

if (threeOfAKindCard == pairCard) 
    continue; 

Je vous suggère de construire votre logiciel dans certaines régions. Essayer de construire un système complet fonctionne rarement, même pour les experts. Construire des pièces, les tester, rincer, répéter. Oui, cela signifie écrire un code d'échafaudage que vous ne pourrez pas faire tourner. Peut-être même une sous-classe de test ... Mais les petites étapes sont plus faciles à travailler. Comme vous vous améliorez en tant que programmeur, vous serez en mesure de prendre de grandes étapes ...