Question

Using a representation of the 52 cards, shuffle them 3 times. then do a radix sort base 2 to get the cards back in order. the order is ace, two,..., king with a suit order of club, diamond, spade, heart. Repeat this time using a radix base 3 sort. Please give the answer in java

Answer 1

package poker;

import java.util.Arrays;

public class PokerHandEvaluator {
  
   //use if checks (ternery operators) whitin the loops and outside you just return
   //check for that 1 edge case where A can be index 0 or 12?
   //change variable names in the for loops
  
   //Pair:
   public static boolean hasPair(Card[] cards) {
       boolean a1, a2, a3, a4;

   /*if ( cards.length != 5 )
   return(false);

   if ( hasFourOfAKind(cards) || hasFullHouse(cards) || hasThreeOfAKind(cards) || hasTwoPair(cards) )
   return(false); // The hand is not one pair (but better)   
*/
   sortByRank(cards);

   /* --------------------------------
   Checking: a a x y z
       -------------------------------- */
   a1 = cards[0].getValue() == cards[1].getValue() ;

   /* --------------------------------
   Checking: x a a y z
       -------------------------------- */
   a2 = cards[1].getValue() == cards[2].getValue() ;

   /* --------------------------------
   Checking: x y a a z
       -------------------------------- */
   a3 = cards[2].getValue() == cards[3].getValue() ;

   /* --------------------------------
   Checking: x y z a a
       -------------------------------- */
   a4 = cards[3].getValue() == cards[4].getValue();

   return( a1 || a2 || a3 || a4 );
   }
  
   //TwoPair:
   public static boolean hasTwoPair(Card[] cards) {
       boolean a1, a2, a3;

   /* if ( cards.length != 5 )
   return(false);
*/
   if ( hasFourOfAKind(cards) || hasFullHouse(cards) || hasThreeOfAKind(cards) )
   return(false); // The hand is not 2 pairs (but better)

   sortByRank(cards);

   /* --------------------------------
   Checking: a a b b x
       -------------------------------- */   
   a1 = cards[0].getValue() == cards[1].getValue() &&
       cards[2].getValue() == cards[3].getValue() ;

   /* ------------------------------
   Checking: a a x b b
       ------------------------------ */
   a2 = cards[0].getValue() == cards[1].getValue() &&
       cards[3].getValue() == cards[4].getValue() ;

   /* ------------------------------
   Checking: x a a b b
       ------------------------------ */
   a3 = cards[1].getValue() == cards[2].getValue() &&
       cards[3].getValue() == cards[4].getValue() ;

   return( a1 || a2 || a3 );
   }
  
   //ThreeOfAKind:
   public static boolean hasThreeOfAKind(Card[] cards) {
      
       boolean a1, a2, a3;

//   if ( cards.length != 5 )
//   return(false);

   sortByRank(cards); // Sort by rank first

   /* ------------------------------------------------------
   Check for: x x x a b
       ------------------------------------------------------- */
   a1 = cards[0].getValue() == cards[1].getValue() &&
       cards[1].getValue() == cards[2].getValue() &&
       cards[3].getValue() != cards[0].getValue() &&
       cards[4].getValue() != cards[0].getValue() &&
       cards[3].getValue() != cards[4].getValue() ;

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

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

   return( a1 || a2 || a3 );

   }
  
   //Straight:
   public static boolean hasStraight(Card [] cards) {
       int i, testRank;

/*   if ( cards.length != 5 )
   return(false);
*/
   sortByRank(cards); // Sort the poker hand by the rank of each card

   /* ===========================
   Check if hand has an Ace
   =========================== */
   if ( cards[4].getValue() == 14 )
   {
   /* =================================
   Check straight using an Ace
   ================================= */
   boolean a = cards[0].getValue() == 2 && cards[1].getValue() == 3 &&
           cards[2].getValue() == 4 && cards[3].getValue() == 5 ;
   boolean b = cards[0].getValue() == 10 && cards[1].getValue() == 11 &&
           cards[2].getValue() == 12 && cards[3].getValue() == 13 ;

   return ( a || b );
   }
   else
   {
   /* ===========================================
   General case: check for increasing values
   =========================================== */
   testRank = cards[0].getValue() + 1;

   for ( i = 1; i < 5; i++ )
   {
   if ( cards[i].getValue() != testRank )
   return(false); // Straight failed...

   testRank++; // Next card in hand
   }

   return(true); // Straight found !
   }
   }
  
   //Flush:
   public static boolean hasFlush(Card[] cards) {
/*       if ( cards.length != 5 )
   return(false); // Make sure we have 5 cards....
*/
   sortBySuit(cards); // Sort the cards by the suit values

   return( cards[0].getSuit() == cards[4].getSuit() );
  
   }
  
   //FullHouse:
   public static boolean hasFullHouse(Card[] cards) {
       boolean a1, a2;

/*   if ( cards.length != 5 )
   return(false);
*/
   sortByRank(cards); // Sort by rank first

   /* ------------------------------------------------------
   Check for: x x x y y
       ------------------------------------------------------- */
   a1 = cards[0].getValue() == cards[1].getValue() &&
       cards[1].getValue() == cards[2].getValue() &&
   cards[3].getValue() == cards[4].getValue();

   /* ------------------------------------------------------
   Check for: x x y y y
       ------------------------------------------------------- */
   a2 = cards[0].getValue() == cards[1].getValue() &&
       cards[2].getValue() == cards[3].getValue() &&
       cards[3].getValue() == cards[4].getValue();

   return ( a1 || a2 );
   }
  
   //FourOfAKind:
   public static boolean hasFourOfAKind(Card[] cards) {
       boolean a1, a2;

/*   if ( cards.length != 5 )
   return(false);
*/
   sortByRank(cards); // Sort by rank first

   /* ------------------------------------------------------
   Check for: 4 cards of the same rank
       + higher ranked unmatched card
       ------------------------------------------------------- */   
   a1 = cards[0].getValue() == cards[1].getValue() &&
       cards[1].getValue() == cards[2].getValue() &&
       cards[2].getValue() == cards[3].getValue();

   /* ------------------------------------------------------
   Check for: lower ranked unmatched card
       + 4 cards of the same rank
       ------------------------------------------------------- */   
   a2 = cards[1].getValue() == cards[2].getValue() &&
       cards[2].getValue() == cards[3].getValue() &&
       cards[3].getValue() == cards[4].getValue() ;

   return( a1 || a2 );
   }
  
   //StraightFlush:
   public static boolean hasStraightFlush(Card[] cards) {
       return hasStraight(cards) && hasFlush(cards);
   }
  
  
   //Helper Method
   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].getSuit() < h[min_j].getSuit())
   {
   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;
   }
   }
  

   //Sort By Rank
   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].getValue() < h[min_j].getValue() )
   {
   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;
   }
   }
  
  
   // A utility function to get maximum value in arr[]
static int getMax(int arr[], int n)
{
int mx = arr[0];
for (int i = 1; i < n; i++)
if (arr[i] > mx)
mx = arr[i];
return mx;
}
  
// A function to do counting sort of arr[] according to
// the digit represented by exp.
static void countSort(int arr[], int n, int exp)
{
int output[] = new int[n]; // output array
int i;
int count[] = new int[10];
Arrays.fill(count,0);
  
// Store count of occurrences in count[]
for (i = 0; i < n; i++)
count[ (arr[i]/exp)%10 ]++;
  
// Change count[i] so that count[i] now contains
// actual position of this digit in output[]
for (i = 1; i < 10; i++)
count[i] += count[i - 1];
  
// Build the output array
for (i = n - 1; i >= 0; i--)
{
output[count[ (arr[i]/exp)%10 ] - 1] = arr[i];
count[ (arr[i]/exp)%10 ]--;
}
  
// Copy the output array to arr[], so that arr[] now
// contains sorted numbers according to curent digit
for (i = 0; i < n; i++)
arr[i] = output[i];
}
  
// The main function to that sorts arr[] of size n using
// Radix Sort
static void radixsort(int arr[], int n)
{
// Find the maximum number to know number of digits
int m = getMax(arr, n);
  
// Do counting sort for every digit. Note that instead
// of passing digit number, exp is passed. exp is 10^i
// where i is current digit number
for (int exp = 1; m/exp > 0; exp *= 10)
countSort(arr, n, exp);
}
}