java - 扑克游戏手评估器数组条件结构

我做了一个快速的扑克游戏。它生成5个随机数字，并将这些数字转换为实际的纸牌值和基于其值的符号。但是，在进行人工评估时，我遇到了问题。

到目前为止，我只做过正确的冲洗，因为它确实很简单，但即使那样也不是完美的（它打印出用户冲洗了5次...），如果有人可以帮助我，我非常感谢这对，两对，三种直率。之后，我可以做剩下的事情，但是我只需要对如何做这些事有所了解。

预先感谢您的帮助，下面是代码：

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");
        }
    }
}

最佳答案

提示：


为了简化对最高顺位牌的顺子测试和排序，更容易通过其索引来表示等级，并将其仅转换为符号以进行打印。
使用Card对象可以使代码更清晰。
Java Collection框架具有用于混排，切片和排序的有用功能。


我的解决方案：

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;
    }
}

输出示例：

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