java - 如何确定 3 Card Game to Find Winner 中的纸牌图案？

Question

我使用从一副 52 张牌中随机抽样创建了 N 三手牌。现在，我想在 N 个人手中找到赢家。

这些是寻找赢家的规则。

1. 试用版(三张牌值相同)
2. 双牌(三张牌的点数顺序相同且花色相同)
3. 跑(连续三张牌)
4. 颜色(三张同花色)
5. 相同(三张牌中有两张有相同的值)
6. 正常情况

卡片的获胜优先级为降序，获得这些卡片的概率为升序。

即

获得试用的概率最小，优先获胜的概率最大，依此类推。

我已经检查了试用的顺序是否正常。

boolean trial = this.checkTrial();
    if(!trial){
        boolean doubleRun = this.checkDoubleRun();
        if(!doubleRun){
            boolean run = this.checkRun();
            if(!run){
                boolean color = this.checkColor();
                if(!color){
                    boolean same = this.checkSame();
                    if(!same){
                        this.checkHighest();
                        System.out.println("Normal");
                    }
                    else{
                        System.out.println("Same");
                    }
                }
                else{
                    System.out.println("Color");    
                }
            }
            else{
                System.out.println("Run");    
            }
        }
        else{
            System.out.println("Double Run");    
        }
    }
    else{
        System.out.println("Trial");    
    }

这是最好的方法吗？

我有两个选择在这两者中找到获胜牌的最佳方法是什么？

• 从最小到最大概率(从试验到正常检查)
• 从大到小的概率(从正常到试验检查)

如有任何建议，我们将不胜感激。

Answer 1

正如我所看到的，您需要构建一个扑克牌游戏系统，包括 3 张扑克牌或 3 张 patti 或同花顺，让我们识别所有涉及的对象

1. Card - 有 2 个属性 Color 和 Cardinality，因此 Class card 将是

    class Card {

        char color;
        short number;

        public Card(char color, short number) {
            this.color = color;
            this.number = number;

        }

        public char getColor() {
            return color;
        }

        public void setColor(char color) {
            this.color = color;
        }

        public short getNumber() {
            return number;
        }

        public void setNumber(short number) {
            this.number = number;
        }
    }

1. Deck - Deck 是一组 52 张牌，因此

    class Deck {

        char[] deckColors = {'♦', '♠', '♣', '♥'};
        short[] cardNum = {(short) 'A', (short) '2', (short) '3', (short) '4', (short) '5', (short) '6', (short) '7',
                           (short) '8', (short) '9', (short) 'T', (short) 'J', (short) 'Q', (short) 'K'};
        int cardCount;

        public Card[] getShuffledDeck() {

            Random r = new Random();


            Card[] deckCards = new Card[(deckColors.length * cardNum.length)];

            int cnt = 0;

            for (char c : deckColors) {
                for (short s : cardNum) {
                    deckCards[cnt++] = new Card(c, s);
                }
            }

            Card[] shuffledDeck = new Card[deckCards.length];

            int addedCount = 0;


            while (addedCount < deckCards.length) {
                int tInt = r.nextInt((deckCards.length));

                Card c = deckCards[tInt];

                if (c != null) {

                    shuffledDeck[addedCount++] = c;
                    deckCards[tInt] = null;

                } else {
                    
                }
            }

            return shuffledDeck;

        }
    }

1. Hand - 一套 3 张牌，但最好使用 getHandRanking() 等方法创建一个类，它实际上会计算发牌的牌力

   class Hand {

        Card[] cards;

        int handRank;

        public Hand(Card[] cards) {

            this.cards = new Card[3];

            //sort all cards
            if (cards[0].getNumber() > cards[1].getNumber()) {
                if (cards[0].getNumber() > cards[2].getNumber()) {
                    //0 index is highest card
                    this.cards[2] = cards[0];
                    if (cards[2].getNumber() > cards[1].getNumber()) {
                        //2 is second highest
                        this.cards[1] = cards[2];
                        this.cards[0] = cards[1];
                    } else {
                        //1 is second highest
                        this.cards[1] = cards[1];
                        this.cards[0] = cards[2];
                    }

                } else {
                    //2 index is highest

                    this.cards[2] = cards[2];
                    if (cards[0].getNumber() > cards[1].getNumber()) {
                        //0 is second highest
                        this.cards[1] = cards[0];
                        this.cards[0] = cards[1];
                    } else {
                        //1 is second highest
                        this.cards[1] = cards[1];
                        this.cards[0] = cards[0];
                    }
                }

            } else {
                if (cards[1].getNumber() > cards[2].getNumber()) {
                    //1 index is highest card
                    this.cards[2] = cards[1];
                    if (cards[2].getNumber() > cards[0].getNumber()) {
                        //2 is second highest
                        this.cards[1] = cards[2];
                        this.cards[0] = cards[0];
                    } else {
                        //0 is second highest
                        this.cards[1] = cards[0];
                        this.cards[0] = cards[2];
                    }
                } else {
                    //2 index is highest
                    this.cards[2] = cards[2];
                    if (cards[0].getNumber() > cards[1].getNumber()) {
                        //0 is second highest
                        this.cards[1] = cards[0];
                        this.cards[0] = cards[1];
                    } else {
                        //1 is second highest
                        this.cards[1] = cards[1];
                        this.cards[0] = cards[0];
                    }
                }
            }
        }

        public int getHandRank() {
            return handRank > 0 ? handRank : calculateHandRank();
        }

        public int calculateHandRank() {
            //assuming 3 cards dealt
            //Trial - ColorSeq - Seq - Color - Pair
            int[] powerOf2s = {1, 2, 4, 8, 16};
            return ((cards[0].getNumber() == cards[1].getNumber() && cards[1].getNumber() == cards[2].getNumber()) ? 1 : 0) * powerOf2s[4]
                    + (((cards[2].getNumber() - 1 == cards[1].getNumber() && cards[1].getNumber() - 1 == cards[0].getNumber()) && (cards[2].getColor() == cards[1].getColor() && cards[1].getColor() == cards[0].getColor())) ? 1 : 0) * powerOf2s[3]
                    + ((cards[2].getNumber() - 1 == cards[1].getNumber() && cards[1].getNumber() - 1 == cards[0].getNumber()) ? 1 : 0) * powerOf2s[2]
                    + (((cards[2].getColor() == cards[1].getColor() && cards[1].getColor() == cards[0].getColor())) ? 1 : 0) * powerOf2s[1]
                    + ((cards[0].getNumber() == cards[1].getNumber() || cards[1].getNumber() == cards[2].getNumber() || cards[0].getNumber() == cards[2].getNumber()) ? 1 : 0) * powerOf2s[0];

        }
    }

现在你只需要查看所有玩家手牌中哪个玩家的手牌等级最高，如果两个玩家恰好有相同的手牌等级则按 Hand.cards[2],[1], 顺序查看谁的牌大[0].

如果需要任何解释，请告诉我。

算法可以大大改进，给出的代码示例只是为了展示思路。