Arrays and Poker Probability

[Shal Lango]

I am having trouble with coding for three of a kind and flush. So what I am stuck on is implementing a hand as an ArrayList of Card objects so that I can add cards to it at run-time using the dealCard() method in DeckOfCards. And then I have to do these two methods in the DeckOfCardsTest file:
static boolean isThreeOfKind( ArrayList<Card> hand )
//A hand is a 3OAK if 3 of the cards have the same face, and the other two do not.  Additionally, the other two cards may not be the same face as each other.
static boolean isFlush( ArrayList<Card> hand )
//A hand is a Flush if all of the cards are the same suit.
Thank you for any suggestions or help in advance!

// Fig. 7.9: Card.java
// Card class represents a playing card.

public class Card 
{
   private final String face; // face of card ("Ace", "Deuce", ...)
   private final String suit; // suit of card ("Hearts", "Diamonds", ...)

   // two-argument constructor initializes card's face and suit
   public Card(String face, String suit)
   {
      this.face = face;
      this.suit = suit; 
   } 
   
   public String getSuit() { 
		String cardSuit = suit; 
		return(cardSuit);
   }
   
   public String getFace() { 
   
		String cardFace = face;
		return(cardFace);
   }

   // return String representation of Card
   public String toString() 
   { 
      return face + " of " + suit;
   } 
} // end class Card

/**************************************************************************

import java.security.SecureRandom;

public class DeckOfCards
{
   private Card[] deck; // array of Card objects
   private int currentCard; // index of next Card to be dealt (0-51)
   private static final int NUMBER_OF_CARDS = 52; // constant # of Cards
   // random number generator
   private static final SecureRandom randomNumbers = new SecureRandom();

   // constructor fills deck of Cards
   public DeckOfCards()
   {
      String[] faces = {"Ace", "Deuce", "Three", "Four", "Five", "Six", 
         "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"};
      String[] suits = {"Hearts", "Diamonds", "Clubs", "Spades"};

      deck = new Card[NUMBER_OF_CARDS]; // create array of Card objects
      currentCard = 0; // first Card dealt will be deck[0]

      // populate deck with Card objects
      for (int count = 0; count < deck.length; count++) 
         deck[count] = 
            new Card(faces[count % 13], suits[count / 13]);
   } 

   // shuffle deck of Cards with one-pass algorithm
   public void shuffle()
   {
      // next call to method dealCard should start at deck[0] again
      currentCard = 0; 

      // for each Card, pick another random Card (0-51) and swap them
      for (int first = 0; first < deck.length; first++) 
      {
         // select a random number between 0 and 51 
         int second =  randomNumbers.nextInt(NUMBER_OF_CARDS);
         
         // swap current Card with randomly selected Card
         Card temp = deck[first];        
         deck[first] = deck[second];   
         deck[second] = temp;            
      } 
   } 

   // deal one Card
   public Card dealCard()
   {
      // determine whether Cards remain to be dealt
      if (currentCard < deck.length)
         return deck[currentCard++]; // return current Card in array
      else        
         return null; // return null to indicate that all Cards were dealt
   } 
} // end class DeckOfCards

*******************************************************************

public class DeckOfCardsTest
{
   // execute application
   public static void main(String[] args)
   {
      ArrayLst<Card[]> handList = new ArrayList<Card[]>(); //how do I add a new hand array each time to the array list?
	  DeckOfCards myDeckOfCards = new DeckOfCards();
      myDeckOfCards.shuffle(); // place Cards in random order
      
      // print all 52 Cards in the order in which they are dealt
      for (int i = 1; i <= 52; i++)
      {
         // deal and display a Card
         System.out.printf("%-19s", myDeckOfCards.dealCard());

		 if (i % 4 == 0) // output a newline after every fourth card
		    System.out.println();
      }
		//my additions:
		myDeckOfCards.shuffle();
		Card[] hand = new Card[5];
		Card[] temp = new Card[52];
		
		intcount = 0;
		int listCount = 0;
		
		for (int i = 0;i < 52; i++)
		{
			temp[i] = myDeckOfCards.dealCard();
			hand[count] = temp[i];
			count++;
			
			if (count == hand.length)
			{
				handList.add(listCount,hand);
				listCount++;
				count = 0;
				continue;
			}
		}
		System.out.println(handList.size());
		System.out.println();
		
		for (int i = 0; i < handList.size(); i++)
		{
			Card[] handF = handList.get();
			for (int j = 0; j < handF.length;j++)
				System.out.println(handF[j] + " ");
			System.out.println();
		}
   } 
   
   public static isThreeOfKind(ArrayList<Card> hand)
   {
	   //look at first card.face
	//how many other cards have the same face
	//if not 2, returnval = false
	//else
	//find other two carsd that aren't face
	//if they have same face, returnval = false
	
	//do this with 3 cards

	//probability, roughly 
	//3 oak = 2.1128%
	//flush = 0.1965%
   else, returnval  = true
   }
   
   public static isFlush(ArrayList<Card> hand)
   {
	   
   }
} // end class DeckOfCardsTest

[Norman Radder]

am having trouble with coding for three of a kind and flush.

Please explain what problems you are having?
How would you solve the problem if you had physical cards in your hand?

[Junilu Lacar]

1. Your shuffle implementation suffers from a flaw that Joshua Bloch describes in the "Lost in the Shuffle" (Puzzler #94) of his "Java Puzzlers" book. Short story: your shuffle algorithm is not a fair random shuffle.

2. Try counting how many of each face you have in the hand first. Then go from there. I would actually try to just write some code that said exactly what you said: "3 of the cards have the same face, and the other two do not. Additionally, the other two cards may not be the same face as each other." If you think about in terms of counting how many different faces you have in the hand, then the problem going forward gets a lot easier.

     // pseudocode
     count how many occurrences of each face are in the hand
     if there are only three distinct face values in the hand and there's a face value with three occurrences:
         well, now we know, don't we?

The first cut of real code might be something like:

faceCounts = howManyOfEachFaceAreIn(hand);
if (hasExactlyThreeDistinctFacesIn(faceCounts) && hasFaceWithThreeOccurrencesIn(faceCounts)) {
    // well, now we know, don't we?
}

Yes, the names are wordy but I'm trying to show how I'd translate from pseudocode to actual code. Once you see that the logic makes sense, then you can start whittling down those names to make them less verbose and more succinct.

[Junilu Lacar]

If you're wondering how you'd count the occurrences of each face in a hand, an analogous problem would be to count how many occurrences of each letter there are in a sentence.  For example, "apples are good for you" has these counts: 'A' - 2, 'P' - 2, 'L' - 1, 'E' - 2, 'S' - 1, 'R' - 2, 'G' - 1, 'O' - 4, 'D' - 1, 'F' - 1, 'Y' - 1, and 'U' - 1.  You just need to find an appropriate data structure to store this information in.