Adriann Adriann - 18 days ago 6
Java Question

Poker game hand evaluator arrays condition structure

I made up a quick poker game. It generates 5 random numbers and converts those numbers into actual cards values and symbols based on their value. However, I have problems when it comes to making the hand evaluation.

So far I only did the flush right as it's really easy but even then it's not perfect (it prints that the user has a flush 5 times... ) and I would really appreciate if someone could help me with the pair, two pair, three of a kind and straight. I could do the rest afterwards but I just need a heads-up on how to do those.

Thank you in advance for your help, here is the code :

package tests;

import java.util.*;

public class TESTS {

public static void main(String[] args) {
boolean[] pack = new boolean[52]; // Array to not generate the same number twice
int[] cards = new int[5]; //The 5 unique random numbers are stored in here.
String[] cardsvalues = new String[5]; // This will assign the card's value based on the random number's value
char[] cardssymbols = new char[5];//This will assign the card's symbol based on the random number's value
char symbols[] = {'♥', '♦', '♣', '♠'}; // possible symbols that the random number can take
String values[] = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"}; // possible values that the random number can take
Random give = new Random();

for (int i = 0; i < cards.length; i++) { // Gives 5 unique random numbers
do {
cards[i] = give.nextInt(52);
} while (pack[cards[i]]);
pack[cards[i]] = true;
System.out.println(cards[i]);
}

for (int i = 0; i < cards.length; i++) { // This converts the number to a card symbol based on the number's value
final int numOfSymbol = cards[i] / 13;
cardssymbols[i] = symbols[numOfSymbol];
}
for (int i = 0; i < cards.length; i++) { // This converts the number to an actual card value based on the number's value.
final int numOfValues = cards[i] % 13;
cardsvalues[i] = values[numOfValues];
}
for (int i = 0; i < cardssymbols.length; i++) { // Prints the actual cards once they are converted
System.out.print(cardssymbols[i]);
System.out.println(cardsvalues[i]);
}
for (int i = 0; i < cardsvalues.length; i++) { //Here is the problem, i have no idea on how to make the handevaluator ...
if (cardsvalues[i] == cardsvalues[i] + 1) {
System.out.println("PAIR !!!");
} else if (cardsvalues[i] == cardsvalues[i] + 1 && cardsvalues[i] == cardsvalues[i] + 2) {
System.out.println("TRIPS !!!");
} else if (cardssymbols[0] == cardssymbols[1] && cardssymbols[1] == cardssymbols[2] && cardssymbols[2] == cardssymbols[3] && cardssymbols[3] == cardssymbols[4]) {
System.out.println("FLUSHHH");
}
}
}

Answer

Hints:

  • To simplify testing for straights and sorting by highest card, it is easier to represent ranks by their indexes, and only translate them to the symbols for printing.
  • Using a Card object allows for clearer code.
  • The Java Collection framework has useful functions for shuffling, slicing and sorting.

My solution:

public class Test {

    static final char[] suits = {'♥', '♦', '♣', '♠'};
    static final String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};

    static class Card {
        final int suit;
        final int rank;

        Card(int s, int r) {
            suit = s;
            rank = r;
        }

        @Override
        public String toString() {
            return suits[suit] + ranks[rank]; // or however you want the cards to be printed
        }
    }


    public static void main(String[] args) {
        List<Card> deck = new ArrayList<>();
        for (int s = 0; s < suits.length; s++) {
            for (int r = 0; r < ranks.length; r++) {
                deck.add(new Card(s,r));
            }
        }
        Collections.shuffle(deck);
        List<Card> hand = deck.subList(0,5);

        Collections.sort(hand, Comparator.comparing(c -> c.rank));
        System.out.println("Your hand is: " + hand);

        System.out.println(value(hand));

    }

    static String value(List<Card> hand) {
        boolean straight = true;
        boolean flush = true;
        for (int i = 1; i < hand.size(); i++) {
            straight &= hand.get(i - 1).rank + 1 == hand.get(i).rank;
            flush &= hand.get(i - 1).suit == hand.get(i).suit;
        }

        if (straight && flush) {
            return "Straight Flush from " + hand.get(4);
        }

        List<Run> runs = findRuns(hand);
        runs.sort(Comparator.comparing(r -> -r.rank));
        runs.sort(Comparator.comparing(r -> -r.length));

        if (runs.get(0).length == 4) {
            return "Four of a Kind: " + runs;
        }

        if (runs.get(0).length == 3 && runs.get(1).length == 2) {
            return "Full House: " + runs;
        }

        if (straight) {
            return "Straight from " + hand.get(4);
        }

        if (runs.get(0).length == 3) {
            return "Three of a Kind: " + runs;
        }

        if (runs.get(1).length == 2) {
            return "Two pair: " + runs;
        }

        if (runs.get(0).length == 2) {
            return "Pair: " + runs;
        }

        return "High card: " + runs;
    }

    /** Represents {@code length} cards of rank {@code rank} */
    static class Run {
        int length;
        int rank;

        @Override
        public String toString() {
            return ranks[rank];
        }
    }

    static List<Run> findRuns(List<Card> hand) {
        List<Run> runs = new ArrayList<>();
        Run run = null;
        for (Card c : hand) {
            if (run != null && run.rank == c.rank) {
                run.length++;
            } else {
                run = new Run();
                runs.add(run);
                run.rank = c.rank;
                run.length = 1;
            }
        }
        return runs;
    }
}

Example output:

Your hand is: [♣10, ♥J, ♦J, ♠K, ♥K]
Two pair: [K, J, 10]
Comments