Question

1. Problem Description

Language: JAVA

The game of Poker Dice is a bit like standard poker but played with dice instead of cards. In this game, five fair dice are rolled. We will recognize one of seven different hands, in order of increasing value:

1. None alike: Five distinct die values occur. Example: 1, 3, 4, 5, 6

2. One Pair: Four distinct die values occur; one die value occurs twice and the other three die

   values occur once each. Example: 1, 2, 3, 3, 5

3. Two Pairs: Three distinct die values occur; two different die values occurs twice and the other

   die value occurs once each. Example: 1, 1, 3, 4, 4

4. Three of a Kind: Three distinct die values occur; one die value occurs three times and the other

   two die values occur once each. Example: 2, 3, 4, 4, 4

5. Full House: Two distinct die values occur; one die value occurs three times and the other die

   value occurs twice. Example: 4, 4, 6, 6, 6

6. Four of a kind: Two distinct die values occur; one die value occurs four times and the other

   die value occurs once. Example: 3, 5, 5, 5, 5

7. Five of a kind: Once die value occurs five times. Example: 2, 2, 2, 2, 2

In our simplified version of the game, this is a one-roll sudden death. You are not given another chance to re-roll some of your dice to improve your hand. When played between two people, the higher hand wins (e.g. Three of a Kind beats Two Pair, Five of a Kind beats all, etc.).

However, we aren’t concerns with actually playing the game, but calculating the odds of each particular hand. The program will roll the dice a number of times and keep track of how many times each hand occurs. Afterwards, display the % of times that each hand occurs.

Run the application with 100 trials, 1000 trials, 10,000 trials and finally 1,000,000 trials. As the number of trials goes up, you will get closer and closer to the mathematical answers shown below:

      

Case

Description

Approx. Calculated Value

1. None   0.09259

2. One Pair  0.46296

3. Two Pairs   0.23148

4. Three of a Kind 0.15432

5. Full House 0.03858

6. Four of a Kind 0.01929

7. Five of a Kind   0.00077

• For this problem you will build on the Die class you created.

• Your source code should be set to roll the dice 1,000,000 times.

• Turn in only your source files.

• Do not use a package.

3. Required Main Class

   - PokerDice

4. Required Input

   None

5. Required Output

   Your output should look something like the following example. It must include your name, number of trials, name of each hand and its probability (as a decimal with six digits after the decimal point).

   Your numbers will likely be a little different since this simulation is based on random numbers. However, as your number of trials increases, they should get closer and closer to the mathematically calculated values estimated in the table above.

   Poker Dice Probability Calculator - E. Eckert Running 1,000,000 trials

Case 1,  None alike,      is 0.092533
Case 2,  One pair,        is 0.462799
Case 3,  Two pair,        is 0.231789
Case 4,  Three of a kind, is 0.154192
Case 5,  Full house,      is 0.038595
Case 6,  Four of a kind,  is 0.019316
Case 7,  Five of a kind   is 0.000776
    
       

Answer 1

If you have any problem with the code feel free to comment.

Program

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

/*Die class*/
class Die {
   private int sides;
   private int value;

   public Die() {
       sides = 6;
   }

   public Die(int sides) {
       this.sides = sides;
   }

   public int getSides() {
       return sides;
   }

   public int getValue() {
       return value;
   }

   public void roll() {//roll method
       value = (int) (Math.random() * (sides - 1) + 1);
   }
}

public class Test {//driver class for testing
   public static void main(String[] args) {
       double case1, case2, case3, case4, case5, case6, case7;
       case1 = case2 = case3 = case4 = case5 = case6 = case7 = 0;

       int[] hand = new int[5];

       //objects of Die
       Die die1 = new Die();
       Die die2 = new Die();
       Die die3 = new Die();
       Die die4 = new Die();
       Die die5 = new Die();

       int runtime = 1000000;//runtime of the loop

       for (int i = 0; i < runtime; i++) {

           //rolling the die
           die1.roll();
           die2.roll();
           die3.roll();
           die4.roll();
           die5.roll();

           //storing the result in an array
           hand[0] = die1.getValue();
           hand[1] = die2.getValue();
           hand[2] = die3.getValue();
           hand[3] = die4.getValue();
           hand[4] = die5.getValue();
          
           //checking the condition
           if (fullHouse(hand)) {
               case5++;
           } else if (onePair(hand)) {
               case2++;
           } else if (twoPair(hand)) {
               case3++;
           } else if (threeOfAKind(hand)) {
               case4++;
           } else if (fourOfAKind(hand)) {
               case6++;
           } else if (fiveOfAKind(hand)) {
               case7++;
           } else {
               case1++;
           }
       }

       //calculating rationadn printing the result
       System.out.println("Poker Dice Probablity Calculator - trails: " + runtime);
       System.out.println("Case 1, None alike, is " + (case1 / runtime));
       System.out.println("Case 2, One pair, is " + (case2 / runtime));
       System.out.println("Case 3, Two pair, is " + (case3 / runtime));
       System.out.println("Case 4, Three of a kind, is " + (case4 / runtime));
       System.out.println("Case 5, Full house, is " + (case5 / runtime));
       System.out.println("Case 6, Four of a kind, is " + (case6 / runtime));
       System.out.println("Case 7, Five of a kind, is " + (case7 / runtime));
   }

   //all conditions
   private static boolean fullHouse(int[] hand) {
       if (onePair(hand) && threeOfAKind(hand))
           return true;
       else
           return false;
   }

   private static boolean fiveOfAKind(int[] hand) {
       int tempCount = -1;

       int[] distinct = getDistinct(hand);

       for (int i = 0; i < distinct.length; i++) {
           for (int j = 0; j < hand.length; j++) {
               if (distinct[i] == hand[j]) {
                   tempCount++;
               }
           }
           if (tempCount == 4)
               return true;
           tempCount = -1;
       }
       return false;
   }

   private static boolean fourOfAKind(int[] hand) {
       int tempCount = -1;

       int[] distinct = getDistinct(hand);

       for (int i = 0; i < distinct.length; i++) {
           for (int j = 0; j < hand.length; j++) {
               if (distinct[i] == hand[j]) {
                   tempCount++;
               }
           }
           if (tempCount == 3)
               return true;
           tempCount = -1;
       }
       return false;
   }

   private static boolean threeOfAKind(int[] hand) {
       int tempCount = -1;

       int[] distinct = getDistinct(hand);

       for (int i = 0; i < distinct.length; i++) {
           for (int j = 0; j < hand.length; j++) {
               if (distinct[i] == hand[j]) {
                   tempCount++;
               }
           }
           if (tempCount == 2)
               return true;
           tempCount = -1;
       }
       return false;
   }

   private static boolean twoPair(int[] hand) {
       int count = 0;
       int tempCount = -1;

       int[] distinct = getDistinct(hand);

       for (int i = 0; i < distinct.length; i++) {
           for (int j = 0; j < hand.length; j++) {
               if (distinct[i] == hand[j]) {
                   tempCount++;
               }
           }
           if (tempCount == 1)
               count += tempCount;
           tempCount = -1;
       }

       if (count == 2)
           return true;
       return false;
   }

   private static boolean onePair(int[] hand) {
       int count = 0;
       int tempCount = -1;

       int[] distinct = getDistinct(hand);

       for (int i = 0; i < distinct.length; i++) {
           for (int j = 0; j < hand.length; j++) {
               if (distinct[i] == hand[j]) {
                   tempCount++;
               }
           }
           if (tempCount == 1)
               count += tempCount;
           tempCount = -1;
       }

       if (count == 1)
           return true;
       return false;
   }

   //getting the distinct elemenets from the hand array
   private static int[] getDistinct(int[] hand) {
       Set<Integer> set = new TreeSet<>();
       for (int i = 0; i < hand.length; i++) {
           set.add(hand[i]);
       }

       Iterator<Integer> itr = set.iterator();
       int[] ar = new int[set.size()];
       int i=0;
      
       while(itr.hasNext()) {
           ar[i++] = itr.next();
       }
      
       return ar;
   }

}

Output