---

Designing the Poker library: Checking for Poker hands

---

• Methods used to check for Poker hands
  • The different types of Poker hands that need to be checked:

    Flush Straight (Straight flush is a Straight that is also a Flush) Four of a Kind Full House Set (Three of a Kind) Two pairs One pair

    ---

  • Checking for each type of Poker hand will be performed by one method

  ---

  ---

  ---

  ---

• What kind of method should we use: class or instance method ?
  • In order to decide what kind of method (class or instance), we need to examine the input data

    ---

  • Input(s) of the methods:

    Explanation:

    Each of the methods operates on a Poker hand (The methods are used to determine the strength of a Poker hand)

    ---

    ---

  • How did we decide to represent a Poker hand:

    As an array of Card objects Card[] player1;

    ---

    ---

    ---

  • Rule for deciding on the kind of method to use:

    If the information is stored inside an object, the operation is implemented as a instance method Example: IF the class PokerHand store a Poker hand PokerHand player1; // player1 is an object we will use instance methods (inside the class PokerHand) to implement the operations If the information is NOT stored inside an object, the operation is implemented as a instance method Example: Card[] player1; // player1 is an array we must use class methods (inside the class PokerHand) to implement the operations

    ---

    ---

  • Conclusion:

    We should use class method I.e.: use the keyword static !!! We will call the class that contains the Poker hand method: Poker            The Poker class will then look something like this: public class Poker { ... define class variables (if necessary) .... // Use class methods to check on // the input poker hand h public static boolean isFlush( Card[] h ) { .... } public static boolean isStraight( Card[] h ) { .... } ... } Notice that: The Poker hand is passed in explicitly using the parameter variable Card[] h

  ---

  ---

  ---

  ---

• Rationale for making sine, cosine, etc as class methods
  • You can now understand why Java define the methods sin, cos, etc. as class methods

    ---

  • Input(s) of the sin, cos, etc. methods:

    ---

  • A floating point number is not an object

  • Therefore:

    Sin, cos, etc. methods are defined as class methods

  ---

  ---

  ---

  ---

  ---

  ---

• Summary of the methods
  • We will present the following Poker hand checking methods (in the order given)

    isFlush( Card[] h ): detects whether the Poker hand h contains a flush isStraight( Card[] h ): detects whether the Poker hand h contains a straight is4s( Card[] h ): detects whether the Poker hand h contains a Four of a Kind isFullHouse( Card[] h ): detects whether the Poker hand h contains a Full House is3s( Card[] h ): detects whether the Poker hand h contains a Three of a Kind is22s( Card[] h ): detects whether the Poker hand h contains 2 pairs

  ---

  ---

  ---

  ---

  ---

  ---

• Checking for a flush
  • Let's start simple...

    How do we detect a flush:

    Flush:

    There is one suit of cards in the Poker hand

    Hint:

    Try sorting the cards first....

    ---

  • Algorithm in Pseudo Code:

    Sort the cards in the Poker hand by the suit; if ( lowest suit == highest suit ) Hand contain a flush (only 1 suit of cards in thehand !); else Hand does not contain a flush;

    ---

  • The isFlush() method in Java:

    /* --------------------------------------------- isFlush(): true if h has a flush false otherwise --------------------------------------------- */ public static boolean isFlush( Card[] h ) { if ( h.length != 5 ) return(false); // Make sure we have 5 cards.... sortBySuit(h); // Sort the cards by the suit values return( h[0].suit() == h[4].suit() ); // All cards has same suit }

  ---

  ---

  ---

  ---

• Helper method: sortBySuit()
  • We use the Selection Sort Algorithm to sort the Poker hand

    ---

  • Previously discussed:

    The Selection Sort Algorithm was discussed in the array lecture notes Here is the web page that discusses the Selection Sort Algorithm: click here

    ---

  • The sortBySuit() helper method:

    /* --------------------------------------------- Sort hand by suit: smallest suit card first .... (Finding a flush is eaiser that way) --------------------------------------------- */ public static void sortBySuit( Card[] h ) { int i, j, min_j; /* --------------------------------------------------- The selection sort algorithm --------------------------------------------------- */ for ( i = 0 ; i < h.length ; i ++ ) { /* --------------------------------------------------- Find array element with min. value among h[i], h[i+1], ..., h[n-1] --------------------------------------------------- */ min_j = i; // Assume elem i (h[i]) is the minimum for ( j = i+1 ; j < h.length ; j++ ) { if ( h[j].suit() < h[min_j].suit() ) { min_j = j; // We found a smaller suit value, update min_j } } /* --------------------------------------------------- Swap a[i] and a[min_j] --------------------------------------------------- */ Card help = h[i]; h[i] = h[min_j]; h[min_j] = help; } }

  ---

  ---

  ---

  ---

  ---

  ---

• Checking for a Straight
  • How do we detect a flush:

    Straight:

    The cards are increasing continuously in rank

    Hint:

    Try sorting the cards by the rank first....

    ---

  • Algorithm in Pseudo Code:

    Sort the cards in the Poker hand by the rank; if ( highest rank card == ACE ) Check if other 4 cards are K, Q, J, 10 or 2, 3, 4, 5 else Check if 5 cards are continuous in rank

    ---

  • The isStraight() method in Java:

    public static boolean isStraight( Card[] h ) { int i, testRank; if ( h.length != 5 ) return(false); sortByRank(h); // Sort the poker hand by the rank of each card /* =========================== Check if hand has an Ace =========================== */ if ( h[4].rank() == 14 ) { /* ================================= Check straight using an Ace ================================= */ boolean a = h[0].rank() == 2 && h[1].rank() == 3 && h[2].rank() == 4 && h[3].rank() == 5 ; boolean b = h[0].rank() == 10 && h[1].rank() == 11 && h[2].rank() == 12 && h[3].rank() == 13 ; return ( a || b ); } else { /* =========================================== General case: check for increasing values =========================================== */ testRank = h[0].rank() + 1; for ( i = 1; i < 5; i++ ) { if ( h[i].rank() != testRank ) return(false); // Straight failed... testRank++; // Next card in hand } return(true); // Straight found ! } }

  ---

  ---

  ---

  ---

• Helper method: sortByRank()
  • We also use the Selection Sort Algorithm to sort the Poker hand by the rank values of each card

    ---

  • Previously discussed:

    The Selection Sort Algorithm was discussed in the array lecture notes Here is the web page that discusses the Selection Sort Algorithm: click here

    ---

  • The sortByRank() helper method:

    /* --------------------------------------------- Sort hand by rank: smallest suit card first .... (Finding a flush is eaiser that way) --------------------------------------------- */ public static void sortByRank( Card[] h ) { int i, j, min_j; /* --------------------------------------------------- The selection sort algorithm --------------------------------------------------- */ for ( i = 0 ; i < h.length ; i ++ ) { /* --------------------------------------------------- Find array element with min. value among h[i], h[i+1], ..., h[n-1] --------------------------------------------------- */ min_j = i; // Assume elem i (h[i]) is the minimum for ( j = i+1 ; j < h.length ; j++ ) { if ( h[j].rank() < h[min_j].rank() ) { min_j = j; // We found a smaller rank value, update min_j } } /* --------------------------------------------------- Swap a[i] and a[min_j] --------------------------------------------------- */ Card help = h[i]; h[i] = h[min_j]; h[min_j] = help; } }

    Note:

    All I did were: make a copy of the sortBySuit method Change the method name to sortByRank Change the compare operation to use rank values: h[j].rank() < h[min_j].rank().

  ---

  ---

• Checking for a Straight Flush
  • A Straight Flush is

    A Straight,         and A Flush

    Example:

    ---

  • We can use this to check for a Straight Flush:

    isStraight( PokerHand ) && isFlush( PokerHand )

    ---

    ---

  • Note:

    A Royal Flush is also a Straight Flush A Royal Flush is the Highest Straight Flush A Royal Flush can be checked as follows: isStraight( PokerHand ) && isFlush( PokerHand ) && Highest card == Ace

  ---

  ---

  ---

  ---

• Checking for a Four of a Kind
  • How do we detect a Four of a Kind:

    Four of a Kind:

    4 cards have the same rank The 5th card can be of any rank

    Hint:

    After sorting the cards by the rank, a Four of a Kind hand must be one of the following hands: Lower ranked unmatched card + 4 cards of the same rank 4 cards of the same rank + higher ranked unmatched card

    ---

  • The is4s() method in Java:

    public static boolean is4s( Card[] h ) { boolean a1, a2; if ( h.length != 5 ) return(false); sortByRank(h); // Sort by rank first /* ------------------------------------------------------ Check for: 4 cards of the same rank + higher ranked unmatched card ------------------------------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[1].rank() == h[2].rank() && h[2].rank() == h[3].rank() ; /* ------------------------------------------------------ Check for: lower ranked unmatched card + 4 cards of the same rank ------------------------------------------------------- */ a2 = h[1].rank() == h[2].rank() && h[2].rank() == h[3].rank() && h[3].rank() == h[4].rank() ; Return( a1 || a2 ); }

  ---

  ---

  ---

  ---

• Checking for a Full House
  • How do we detect a Four of a Kind:

    Full House:

    3 cards have the same rank   and 2 remaining cards have the same rank

    Hint:

    After sorting the cards by the rank, a Four of a Kind hand must be one of the following hands: 3 lower ranked cards of same rank + 2 lower ranked cards of same rank 2 lower ranked cards of same rank + 3 lower ranked cards of same rank

    ---

  • The isFullHouse() method in Java:

    public static boolean isFullHouse( Card[] h ) { boolean a1, a2; if ( h.length != 5 ) return(false); sortByRank(h); // Sort by rank first /* ------------------------------------------------------ Check for: x x x y y ------------------------------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[1].rank() == h[2].rank() && h[3].rank() == h[4].rank(); /* ------------------------------------------------------ Check for: x x y y y ------------------------------------------------------- */ a2 = h[0].rank() == h[1].rank() && h[2].rank() == h[3].rank() && h[3].rank() == h[4].rank(); return( a1 || a2 ); }

  ---

  ---

  ---

  ---

• Checking for a Three of a Kind (Set) --- Full Version (without using any other information)
  • How do we detect a Three of a Kind:

    Three of a Kind:

    3cards have the same rank Plus 2 unmatched cards

    Hint:

    After sorting the cards by the rank, a Three of a Kind hand must be one of the following hands: A lower ranked unmatched card + another lower ranked unmatched card + 3 cards of the same rank Lower ranked unmatched card + 3 cards of the same rank + a higher ranked unmatched card 3 cards of the same rank + a higher ranked unmatched card + another higher ranked unmatched card

    ---

    ---

  • The full version is3s() method in Java:

    public static boolean is3s( Card[] h ) { boolean a1, a2, a3; if ( h.length != 5 ) return(false); sortByRank(h); // Sort by rank first /* ------------------------------------------------------ Check for: x x x a b ------------------------------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[1].rank() == h[2].rank() && h[3].rank() != h[0].rank() && h[4].rank() != h[0].rank() && h[3].rank() != h[4].rank() ; /* ------------------------------------------------------ Check for: a x x x b ------------------------------------------------------- */ a2 = h[1].rank() == h[2].rank() && h[2].rank() == h[3].rank() && h[0].rank() != h[1].rank() && h[4].rank() != h[1].rank() && h[0].rank() != h[4].rank() ; /* ------------------------------------------------------ Check for: a b x x x ------------------------------------------------------- */ a3 = h[2].rank() == h[3].rank() && h[3].rank() == h[4].rank() && h[0].rank() != h[2].rank() && h[1].rank() != h[2].rank() && h[0].rank() != h[1].rank() ; return( a1 || a2 || a3 ); }

  ---

  ---

  ---

  ---

• Checking for a Three of a Kind (Set) --- making use of existing methods
  • Fact:

    We have already written methods to test for: 4 of a kind Full house

    We can use these methods in writing the 3 of a kind test method

    ---

  • New approach:

    public static boolean is3s( Card[] h ) { boolean a1, a2, a3; if ( h.length != 5 ) return(false); if ( is4s(h) || isFullHouse(h) ) return(false); // The hand is not 3 of a kind (but better) /* ---------------------------------------------------------- Now we know the hand is not 4 of a kind or a full house ! ---------------------------------------------------------- */ Can we make the test a little more simpler ??? }

    We can use this knowledge to simplify the full version of is3s()

    ---

    ---

  • Example: checking for a "x x x a b" 3 of a Kind hand

    The original test used is: /* ------------------------------------------------------ Check for: x x x a b ------------------------------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[1].rank() == h[2].rank() && h[3].rank() != h[0].rank() && // (1) h[4].rank() != h[0].rank() && // (2) h[3].rank() != h[4].rank() ; // (3) Because we know that is4s() has returned false, we can conclude that: h[3].rank() != h[0].rank() // (1) and h[4].rank() != h[0].rank() // (2) Because if either card h[3] or h[4] has the same rank as the card h[0], the hand is a Four of a Kind !!! So we do not need to include these test since we know that they are satisfied. Also, because we know that isFullHouse() has returned false, we can conclude that: h[3].rank() != h[4].rank() // (3) Because if h[3].rank == h[4].rank, the hand is a Full House !!! So we do not need to include this test since we know that it is satisfied. The simplified checking for a "x x x a b" 3 of a Kind hand is then: /* ------------------------------------------------------ Check for: x x x a b ------------------------------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[1].rank() == h[2].rank() ;

    ---

    ---

    The other 2 cases:

    /* ------------------------------------------------------ Check for: a x x x b ------------------------------------------------------- */ a2 = h[1].rank() == h[2].rank() && h[2].rank() == h[3].rank() && h[0].rank() != h[1].rank() && h[4].rank() != h[1].rank() && h[0].rank() != h[4].rank() ; /* ------------------------------------------------------ Check for: a b x x x ------------------------------------------------------- */ a3 = h[2].rank() == h[3].rank() && h[3].rank() == h[4].rank() && h[0].rank() != h[2].rank() && h[1].rank() != h[2].rank() && h[0].rank() != h[1].rank() ;

    can be simplified into:

    /* ------------------------------------------------------ Check for: a x x x b ------------------------------------------------------- */ a2 = h[1].rank() == h[2].rank() && h[2].rank() == h[3].rank() ; /* ------------------------------------------------------ Check for: a b x x x ------------------------------------------------------- */ a3 = h[2].rank() == h[3].rank() && h[3].rank() == h[4].rank() ;

    ---

  • The simplified version of is3s() in Java:

    public static boolean is3s( Card[] h ) { boolean a1, a2, a3; if ( h.length != 5 ) return(false); if ( is4s(h) || isFullHouse(h) ) return(false); // The hand is not 3 of a kind (but better) sortByRank(h); /* ------------------------------------------------------ Check for: x x x a b ------------------------------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[1].rank() == h[2].rank() ; /* ------------------------------------------------------ Check for: a x x x b ------------------------------------------------------- */ a2 = h[1].rank() == h[2].rank() && h[2].rank() == h[3].rank() ; /* ------------------------------------------------------ Check for: a b x x x ------------------------------------------------------- */ a3 = h[2].rank() == h[3].rank() && h[3].rank() == h[4].rank() ; return( a1 || a2 || a3 ); }

  ---

  ---

  ---

  ---

• Checking for Two Pairs
  • How do we detect a Two Pairs hand:

    Two pairs:

    2 cards have the same rank 2 other cards have the same rank that is different from the first pair The 5th card can be of any unmatched rank

    Hint:

    After sorting the cards by the rank, a Two Pairs hand must be one of the following hands: A lower ranked unmatched card + 2 cards of the same rank + 2 cards of the same rank 2 cards of the same rank + a middle ranked unmatched card + 2 cards of the same rank 2 cards of the same rank + 2 cards of the same rank + a higher ranked unmatched card

    ---

  • The is22s() method in Java:

    public static boolean is22s( Card[] h ) { boolean a1, a2, a3; if ( h.length != 5 ) return(false); if ( is4s(h) || isFullHouse(h) || is3s(h) ) return(false); // The hand is not 2 pairs (but better) sortByRank(h); /* -------------------------------- Checking: a a b b x -------------------------------- */ a1 = h[0].rank() == h[1].rank() && h[2].rank() == h[3].rank() ; /* ------------------------------ Checking: a a x b b ------------------------------ */ a2 = h[0].rank() == h[1].rank() && h[3].rank() == h[4].rank() ; /* ------------------------------ Checking: x a a b b ------------------------------ */ a3 = h[1].rank() == h[2].rank() && h[3].rank() == h[4].rank() ; return( a1 || a2 || a3 ); }

    Note:

    We check for Two Pairs after checking for One Pair and Full House Therefore: We don't need to check if the a value card is not equal to the b value card (Because a == b, we have a Four of a Kind hand !) And ... we don't need to check if the x value card is not equal to the a value card and the b value card (Because x == a or x == b, we have a Full House hand !)

  ---

  ---

  ---

  ---

• Checking for One Pair
  • How do we detect a One Pair hand:

    Two pairs:

    2 cards have the same rank The 3 other cards must be of unmatched rank

    Hint:

    After sorting the cards by the rank, a One Pair hand must be one of the following hands: 3 lower ranked unmatched cards + 2 cards of the same rank 2 lower ranked unmatched cards + 2 cards of the same rank + 1 higher ranked unmatched card 1 lower ranked unmatched card + 2 cards of the same rank + 2 higher ranked unmatched cards 2 cards of the same rank + 3 higher ranked unmatched cards

    ---

  • The is2s() method in Java:

    public static boolean is2s( Card[] h ) { boolean a1, a2, a3, a4; if ( h.length != 5 ) return(false); if ( is4s(h) || isFullHouse(h) || is3s(h) || is22s(h) ) return(false); // The hand is not one pair (but better) sortByRank(h); /* -------------------------------- Checking: a a x y z -------------------------------- */ a1 = h[0].rank() == h[1].rank() ; /* -------------------------------- Checking: x a a y z -------------------------------- */ a2 = h[1].rank() == h[2].rank() ; /* -------------------------------- Checking: x y a a z -------------------------------- */ a3 = h[2].rank() == h[3].rank() ; /* -------------------------------- Checking: x y z a a -------------------------------- */ a4 = h[3].rank() == h[4].rank() ; return( a1 || a2 || a3 || a4 ); }

    Note:

    We check for one pair after checking for Four of a Kind, Full House, Three of a Kind and Two Pairs. Therefore: We don't need to check if the x, y or z value card is not equal to the "a" value card (Because x == a, x == b or x == c we have a Three of a Kind hand !) And ... we don't need to check if the x value card is not equal to the y value card or the z value card (Because x == y or x == z or y == z we have a Two Pairs hand !)

  ---

  ---

  ---

  ---

  ---

  ---

• The Poker Class
  • Here is the Poker class that contains the methods discussed above.

    Note: First find the line:

    /*********************************************************** Methods used to determine a certain Poker hand ***********************************************************/

    The Poker checking method (discussed in this web page) are below this line

    ---

  • The Java Program File: (see the above code)                                                
    • The Poker.java Prog file: click here

    How to use the program:

    The Poker.java methods are library methods like sin(), cos(), etc. They help you write Poker game programs with very little effort