Advertisement
dimipan80

Full House

Aug 17th, 2014
255
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 3.47 KB | None | 0 0
  1. /* In most Poker games, the "full house" hand is defined as three cards of the same face
  2.  * + two cards of the same face, other than the first, regardless of the card's suits.
  3.  * The cards faces are "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" and "A".
  4.  * The card suits are "♣", "♦", "♥" and "♠".
  5.  * Write a program to generate and print all full houses and print their number. */
  6.  
  7. public class _03_FullHouse {
  8.  
  9.     private static String[] faceCards = { "2", "3", "4", "5", "6", "7", "8",
  10.             "9", "10", "J", "Q", "K", "A" };
  11.  
  12.     private static char[] suitCards = { '\u2663', '\u2666', '\u2665', '\u2660' };
  13.  
  14.     public static void main(String[] args) {
  15.         // TODO Auto-generated method stub
  16.         int countFullHouses = generateAndPrintAllFullHouses();
  17.  
  18.         System.out.println();
  19.         System.out..printf("The all combinations of generated full houses are: %d full houses!%n",
  20.                         countFullHouses);
  21.     }
  22.  
  23.     private static int generateAndPrintAllFullHouses() {
  24.         int counter = 0;
  25.         int[] faces = new int[5];
  26.         int i, j;
  27.         String[] suits;
  28.         for (faces[0] = 0; faces[0] < faceCards.length; faces[0]++) {
  29.             faces[1] = faces[0];
  30.             faces[2] = faces[0];
  31.  
  32.             // Now initialize the string Array for the fifth card suits,
  33.             // and generate all possible combinations for the first 3 suits,
  34.             // without repeating:
  35.             for (i = 0; i < 4; i++) {
  36.                 suits = getTheFirst3CardSuits(i);
  37.  
  38.                 for (faces[3] = 0; faces[3] < faceCards.length; faces[3]++) {
  39.                     if (faces[3] != faces[0]) {
  40.                         faces[4] = faces[3];
  41.  
  42.                         // Here generate all possible combinations without
  43.                         // repeats, for the Last two card suits:
  44.                         for (j = 0; j < 6; j++) {
  45.                             getTheLast2cardSuits(j, suits);
  46.  
  47.                             counter++;
  48.                             printTheNextFullHouse(faces, suits);
  49.                         }
  50.                     }
  51.                 }
  52.             }
  53.         }
  54.  
  55.         return counter;
  56.     }
  57.  
  58.     private static String[] getTheFirst3CardSuits(int key) {
  59.         String[] suits = new String[5];
  60.         switch (key) {
  61.         case 0:
  62.             suits[0] = "" + suitCards[0];
  63.             suits[1] = "" + suitCards[1];
  64.             suits[2] = "" + suitCards[2];
  65.             break;
  66.         case 1:
  67.             suits[0] = "" + suitCards[0];
  68.             suits[1] = "" + suitCards[1];
  69.             suits[2] = "" + suitCards[3];
  70.             break;
  71.         case 2:
  72.             suits[0] = "" + suitCards[0];
  73.             suits[1] = "" + suitCards[2];
  74.             suits[2] = "" + suitCards[3];
  75.             break;
  76.         case 3:
  77.             suits[0] = "" + suitCards[1];
  78.             suits[1] = "" + suitCards[2];
  79.             suits[2] = "" + suitCards[3];
  80.             break;
  81.         }
  82.  
  83.         return suits;
  84.     }
  85.  
  86.     private static void getTheLast2cardSuits(int key, String[] suits) {
  87.         switch (key) {
  88.         case 1:
  89.             suits[3] = "" + suitCards[0];
  90.             suits[4] = "" + suitCards[2];
  91.             break;
  92.         case 2:
  93.             suits[3] = "" + suitCards[0];
  94.             suits[4] = "" + suitCards[3];
  95.             break;
  96.         case 3:
  97.             suits[3] = "" + suitCards[1];
  98.             suits[4] = "" + suitCards[2];
  99.             break;
  100.         case 4:
  101.             suits[3] = "" + suitCards[1];
  102.             suits[4] = "" + suitCards[3];
  103.             break;
  104.         case 5:
  105.             suits[3] = "" + suitCards[2];
  106.             suits[4] = "" + suitCards[3];
  107.             break;
  108.  
  109.         default:
  110.             suits[3] = "" + suitCards[0];
  111.             suits[4] = "" + suitCards[1];
  112.             break;
  113.         }
  114.  
  115.     }
  116.  
  117.     private static void printTheNextFullHouse(int[] faceIndx, String[] suits) {
  118.         StringBuilder fullHouse = new StringBuilder();
  119.         fullHouse.append('(');
  120.         for (int i = 0; i < faceIndx.length; i++) {
  121.             fullHouse.append(faceCards[faceIndx[i]]);
  122.             fullHouse.append(suits[i]);
  123.             if (i < faceIndx.length - 1) {
  124.                 fullHouse.append(' ');
  125.             }
  126.         }
  127.  
  128.         fullHouse.append(" ");
  129.  
  130.         System.out.print(fullHouse);
  131.     }
  132.  
  133. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement