Java 中的扑克手牌

Question

有没有简单的方法来比较两手扑克牌？我的想法很天真，所以如果有人有这方面的经验，那可能会有所帮助。

Answer 1

没有一种简单（且高效）的方法可以做到这一点，特别是如果您想评估七张牌的五张牌子集，例如德州扑克。

您可能想查看 pokersource ，它有一些 Java 绑定。

编辑 - 另一个资源是pokerai 论坛。我在那里发现了很多 Java 算法。它们定期运行基准测试，并且通常伴随着蒙特卡罗模拟的枚举算法。 这似乎是主要帖子。

Answer 2

我发现这个看起来很有希望。

您也可以自己推出。

Answer 3

您可以在此处 附有文档并在此处进一步解释。欢迎通过其中的电子邮件地址提供所有反馈。

Answer 4

看看来自阿尔伯塔大学的免费扑克 Java 库：
http://spaz.ca/poker/doc/ca /ualberta/cs/poker/package-summary.html

Answer 5

假设您已经拥有某种数据结构来确定玩家拥有的手牌类型，您可以为每种类型的手牌分配某种 int 值并进行比较。任何拥有更高价值的玩家都会获胜。如果值相等，您只需比较两手牌即可。即，如果双方都有对子，则只需比较卡片的数量，或者如果他们都有葫芦，则比较他们拥有 3 张卡片的价值。

编辑：如果他们有相同的手牌，只需检查他们手中的下一张最高的牌（踢球者）。

Answer 6

我为 java 编写了一个扑克牌评估库，它正是您所寻找的。
这并不容易，但它很高效。我在 GitHub 上根据 GNU GPL 发布了它。

在此处获取源代码

Answer 7

我写了这个，如果有帮助请告诉我。本质上，我将每张牌映射到黑桃 2 为 0，黑桃 A 为 12，红心 2 为 3 等等。
我希望在投入工作之前看到这个线程。

  /**
     * Takes any subset of numberCards and creates an array which directly says
     * how good the cards are This method is long so If it is working try not to
     * tweak it TODO potential re-factor
     *
     * @todo Fix this @fixMe
     * @param cards to analyze
     * @return condensed form of hand in the format(tier, High Card, High Card
     * 2,Kicker(s),sometimes some zeroes)
     */
    public static int[] analyzeCards(int[] cards) {
        int suitFlush = 0;
        int[] unsuitedCards = new int[cards.length];
        for (int i = 0; i < cards.length; i++) {
            unsuitedCards[i] = (cards[i] % 13);
        }
                Arrays.sort(unsuitedCards);
        unsuitedCards = reverse(unsuitedCards);
 //converting cards into just numbers 0-12 in descending order

        
        int[] lookForPairsHere=unsuitedCards.clone();

//        System.out.println(Arrays.toString(unsuitedCards));
        //defining the suits of the cards 0,1,2,3
        // and the suits are in order of the cards
        int[] suitsOfCards = new int[cards.length];
        for (int i = 0; i < cards.length; i++) {
            suitsOfCards[i] = cards[i] / 13;
        }
        int[] numberOfEachValuedCard = {0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0};
        int[] pairs = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

        lookForPairsHere = unsuitedCards.clone();

        int[] originalCards = cards.clone();
        int[] condensedCards = {0, -1, 0, 0, 0, 0};
        int[] suits = {0, 0, 0, 0};
        boolean[] hasQuality = {false, false}; // hasQuality[0] is flush and 
        //hasQuality[1] is a straight
        for (int i = 0; i < suitsOfCards.length; i++) {
            suits[suitsOfCards[i]]++;
        }
        for (int i = 0; i < 4; i++) {
            if (suits[i] > 4) {
                hasQuality[0] = true;
//                System.out.println("flush");
                // there is a flush!
                suitFlush = i;
                }
        }
int[] straightCards = {-2, -2, -2, -2, -2, -2, -2};
        int i = 0;
        int j = 1;
        int card = 0;
//        some iterators I will need to keep track of temporarily
//         i is just an iterator j is the number of consecuetive cards

if(hasQuality[0]){
        for (i = 0; i <originalCards.length; i++) {
                if (originalCards[i]/13 == suitFlush) {
                    straightCards[i] = originalCards[i];
                }
            }
Arrays.sort(straightCards);
straightCards=reverse(straightCards);
//sorting flushCards in order;
        unsuitedCards = removeDuplicates(unsuitedCards);
        // getting rid of duplicates to prevent trouble
condensedCards[1]=straightCards[0]%13;
}
        if (/*there is not a flush already*/!hasQuality[0]) {
                for(i=0;(i<unsuitedCards.length-5);i++){
                    if(unsuitedCards[i]-1==unsuitedCards[i+1]&&
                            unsuitedCards[i]-2==unsuitedCards[i+2]&&
                            unsuitedCards[i]-3==unsuitedCards[i+3]&&
                            unsuitedCards[i]-4==unsuitedCards[i+4]){
                        hasQuality[1]=true;
                        condensedCards[1]=unsuitedCards[i];
                }
                }
            if (hasQuality[1] == false) {
                int b = 0;
                if (unsuitedCards[0] == 12) {
                    //looks for ace-5 flush
                    for (i = 0; i < unsuitedCards.length; i++) {
                        if (unsuitedCards[i] == 3 || unsuitedCards[i] == 2 || unsuitedCards[i] == 1
                                || unsuitedCards[i] == 0) {
                            b++;
                        }
                    }
                    if (b>3) {
                        hasQuality[1] = true;
                        //there is an ace-5 flush
                        condensedCards[1] = 3;
                    }
                }
            }
        } else/*there is a flush already so a straight is suited*/ {
            Arrays.sort(straightCards);
            straightCards = reverse(straightCards);
            //order it
            // look for A normal straight    
            for(i=0;(i<straightCards.length-5);i++){
                    if(straightCards[i]-1==straightCards[i+1]&&
                            straightCards[i]-2==straightCards[i+2]&&
                            straightCards[i]-3==straightCards[i+3]&&
                            straightCards[i]-4==straightCards[i+4]){
                        hasQuality[1]=true;
                        condensedCards[1]=straightCards[i];
                }
            }
            if (hasQuality[1] == false) {
                int b = 0;
                if (straightCards[0] == 12) {
                    //looks for ace-5 flush
                    for (int z = 0; (z< straightCards.length); z++){
                        if (straightCards[z] == 3 || straightCards[z] == 2 || 
                                straightCards[z] == 1
                                ||straightCards[z] == 0) {
                            b++;
                        }
                    }
                    if (b>3) {
                        hasQuality[1] = true;
                        //there is an ace-5 flush
                        condensedCards[1] = 3;
                    }
                }
            }
        }
        if (hasQuality[1] && hasQuality[0]) {
            condensedCards[0] = 8;
            return condensedCards;
        }
        if (hasQuality[1] && !hasQuality[0]) {
            condensedCards[0] = 4;
            return condensedCards;
        }
        if (hasQuality[0] && !hasQuality[1]) {
            condensedCards[0] = 5;
            for(i=2;i<=5;i++){
                condensedCards[i]=straightCards[i-1];
            }
            return condensedCards;
        }
        card = 0;

        for (i = 0; i < lookForPairsHere.length; i++) {
            numberOfEachValuedCard[lookForPairsHere[i]]++;
        }
        for (i = 12; i >= 0 && card < 5; i--) {
            // create an array that has how much of each card
            if (numberOfEachValuedCard[i] > 0) {
                pairs[2 * card] = numberOfEachValuedCard[i];
                pairs[2 * card + 1] = i;
                card++;
            }
        }

//parse the array above
        int[] pairCondensed = {0, 0, 0, 0, 0};
        for (i = 0; i < 5; i++) {
            pairCondensed[i] = pairs[2 * i];
        }
        //highest to lowest
        Arrays.sort(pairCondensed);
        pairCondensed = reverse(pairCondensed);

        if (pairCondensed[0] == 4 && pairCondensed[1] == 1) {
            //four of a kind
            condensedCards[0] = 7;
            for (i = 0; pairs[i] > 0; i += 2) {
                if (pairs[i] == 4) {
                    condensedCards[1] = pairs[i + 1];
                }
                for (j = 0; j < 10; j += 2) {
                    if (pairs[j] == 1) {
                        condensedCards[2] = pairs[j + 1];
                        break;
                    }
                }
            }
            return condensedCards;
        }
        if (pairCondensed[0] == 3 && pairCondensed[1] == 2) {
            //full house
            condensedCards[0] = 6;
            for (i = 0; i < 10; i += 2) {
                if (pairs[i] == 3) {
                    condensedCards[1] = pairs[i + 1];
                }
                if (pairs[i] == 2) {
                    condensedCards[2] = pairs[i + 1];
                }
            }
            return condensedCards;
        }
        if (pairCondensed[0] == 3 && pairCondensed[1] == 1) {
            //three kind
            condensedCards[0] = 3;
            for (i = 0; i < 10; i += 2) {
                if (pairs[i] == 3) {
                    condensedCards[1] = pairs[i + 1];
                }
            }

            //kicker stuff here
            j = 3;
            for (i = 0; j < 5; i++) {
                if (unsuitedCards[i] != condensedCards[1]) {
                    condensedCards[j] = unsuitedCards[i];
                    j++;
                }
            }
        }
        if (pairCondensed[0] == 2 && pairCondensed[1] == 2) {

//two pair
            condensedCards[0] = 2;
            for (i = 0; i < 10; i += 2) {
                if (pairs[i] == 2 && condensedCards[1] == -1) {
                    condensedCards[1] = pairs[i + 1];
                }
                if (pairs[i] == 2 && condensedCards[1] != -1) {
                    condensedCards[2] = pairs[i + 1];
                }
            }
            if (condensedCards[2] > condensedCards[1]) {
                int temp2 = condensedCards[2];
                int temp1 = condensedCards[1];
                condensedCards[1] = temp2;
                condensedCards[2] = temp1;
            }

            //kicker stuff here
            j = 3;
            for (i = 0; j < 4; i++) {
                if (unsuitedCards[i]
                        != condensedCards[1] && unsuitedCards[i]
                        != condensedCards[2]) {
                    condensedCards[j] = unsuitedCards[i];
                    j++;
                }
            }
        }
        if (pairCondensed[0] == 2&&pairCondensed[1]==1) {
            //one pair
            condensedCards[0] = 1;
            for (i = 0; i < 10; i += 2) {

                if (pairs[i] == 2) {
                    condensedCards[1] = pairs[i + 1];
                }
            }
            //kicker stuff here
            j = 3;
            for (i = 0; j < 6 && i < 5; i++) {
                if (unsuitedCards[i] != condensedCards[1]) {
                    condensedCards[j] = unsuitedCards[i];
                    j++;
                }
            }
        }

        if (condensedCards[0] == 0) {
            //high card/ no pair
            for (i = 0,j=1; j <=5 && i < originalCards.length; i++) {
condensedCards[j]=lookForPairsHere[i];
                j++;
            }
        }

        return condensedCards;
    }