Question

这只是代码的一部分，所以不要紧，如果你看不到数组或其他任何东西。我的想法是我有5张卡，我想确定哪些是对。有谁理解我的意思？

boolean IsOnePair=true;

int [] cont = new int [6];

for (int i=0;i<Game.length;i++)
{
    cont[Game[i].getValue()] ++;
}

for (int i=0;i<cont.length;i++)
{
    if (cont[Game[i].getValue()]==2)
    {
        IsOnePair=false;
        System.out.println(Game+" : "+cont[i]+" times");
    }
}

Answer 1

对于一个人来说，你的数组应该只有5个元素，如果你想让它成为真正的扑克手，那么你的数组应该只有6个。

至于确定是否有一对，我只需检查每张卡与其右侧的每张卡。这将在O（n ^ 2）中运行，但只要手的大小保持在5左右，这是可以接受的。

以下是一些代码：

for(i=0; i<5; i++)
{
  for(j=i+1; j<5; j++)
  {
    if(hand[i] == hand[j])
      return true;
  }
 }

此外，您的代码无法正常工作的原因是您尝试访问的索引等于卡片值，而不是卡片的数量。您可以使用字典来执行此操作，但上面的代码编程要简单得多，对于这么小的问题大小，这是可以接受的。

Answer 2

如果您需要快速，您可能需要考虑重新评估您的方法。或者，考虑使用现有的扑克手检测库，或者至少研究其中至少一个的源，以获得一些“灵感”。 Cactus Kev写得非常好5 card hand detection algorithm：

您可能还想阅读http://www.codingthewheel.com/archives/how-i-built-a-working-online-poker-bot-8

Answer 3

你是如何处理套牌的套装的？如果您将卡片表示为简单的整数，那么我假设卡片的有效值为0 - 51.如果是这种情况，那么我猜卡片0 - 12都是一套，13 - 25是另一套，等等。套装的分配可以是任意的，直到你需要考虑到它的得分为止。

通过这种安排，您可以像samoz一样检测一对，并对比较操作进行修改。您需要确保这些卡是全等模13的。只需更改行

即可

if(hand[i] == hand[j])

到

if( (hand[i] % 13) == (hand[j] % 13) )

模数运算符（％）返回除法后的余数，所以

 0 % 13 = 0
 1 % 13 = 1
 2 % 13 = 2
    ...
12 % 13 = 12
13 % 13 = 0
14 % 14 = 1

等等......它允许你告诉一个序列何时包裹某个值，模数，在这种情况下是13，因为在四个套装中每个都有13张不同的牌。

比方说，例如，在你的52张牌中，编号为0 - 51的牌中，牌0 - 12代表通过俱乐部国王的王牌，牌13 - 25代表心脏，26 - 38代表黑桃，39 - 51代表钻石。

现在你处理了手：0,12,32,21,47

通过取每张卡的剩余模数13，你剩下0,12,6,8,8

你可以看到最后两张牌是一对，心中的9张和9颗钻石（记住编号从0开始，所以它被一张掉了。）

Answer 4

我认为你正在寻找一对不同于三种或四种的一对。在这种情况下，你最好的选择是通过每张牌，并存储多少个A，多少2，多少3等等。这个解决方案将为您提供成对的数量，以及是否有三个/四个或满屋。在寻找同花顺或直线时，你当然必须做不同的检查。

Card[] hand = new Card[numberOfCards];
int[] frequencies = new int[13]; // there are 13 card values
...
for (int i = 0; i < hand.Count; i++)
{
    frequencies[hand[i].CardNumber] += 1; // assume Ace = 0, King = 12
}
// Now look through the frequencies:
int numberOfPairs = 0;
bool hasTriple = false;
bool hasFour = false;
for (int f = 0; j < frequencies.Count; j++)
{
    switch (frequencies[f])
    {
         case 2:
             numberOfPairs++;
             break;
         case 3:
             hasTriple = true;
             break;
         case 4:
             hasFour = true;
             break;
         default:
             break;
    }
}
// Now you know how many pairs you have, and whether you have a triple or four-of-a-kind
if (numberOfPairs == 1 && hasTriple)
{
    // It's a full house
}

修改修改它以记录构成对的数字（A对或皇后区等）也是微不足道的。

Answer 5

如果你对手进行分类，那么从左到右阅读它应该相对容易计算出手的力量。

如果你的目标是简单，你可以试试这样的东西（伪代码）：

def handStrength(hand):
    sort(hand) //sorts hand in ascending order
    if hasPair(hand):
        if isTwoPair(hand):
            return "two pair"
        else if isTrips(hand):
            return "three of a kind"
        else if isBoat(hand):
            return "full house"
        else if isQuads(hand):
            return "four of a kind"
        else:
            return "pair"
    else:
        straightFlag = isStraight(hand)
        flushFlag = isFlush(hand)
        if straightFlag:
            if flushFlag:
                return "straight flush"
            else:
                return "straight"
        else if flushFlag:
            return "flush"
        else:
            return "high card"

def hasPair(hand): //requires sorted hand
    for i = 1 to 4:
        if hand[i].rank == hand[i-1].rank:
            return True
    return False

def isTwoPair(hand): //requires sorted hand
    return (hand[0].rank == hand[1].rank and hand[2].rank == hand[3].rank and hand[0].rank != hand[2].rank) or
           (hand[1].rank == hand[2].rank and hand[3].rank == hand[4].rank and hand[1].rank != hand[3].rank)

def isTrips(hand): //requires sorted hand
    return (hand[0].rank == hand[2].rank and hand[0].rank != hand[3].rank and hand[3].rank != hand[4].rank) or
           (hand[1].rank == hand[3].rank and hand[0].rank != hand[1].rank and hand[0].rank != hand[4]) or
           (hand[2].rank == hand[4].rank and hand[1].rank != hand[2].rank and hand[1].rank != hand[0].rank)

def isBoat(hand): //requires sorted hand
    return (hand[0].rank == hand[1].rank and hand[2].rank == hand[3].rank == hand[4].rank) or
           (hand[0].rank == hand[1].rank == hand[2].rank and hand[3].rank == hand[4].rank)

def isQuads(hand): //requires sorted hand
    return hand[1].rank == hand[2].rank == hand[3].rank and (hand[0].rank == hand[1].rank or hand[4].rank == hand[1].rank)

def isStraight(hand): //requires sorted hand with no pair
    return (hand[0].rank == hand[4].rank - 4) or (isAce(hand[0]) and hand[4].rank == 5)

def isFlush(hand):
    return hand[0].suit == hand[1].suit == hand[2].suit == hand[3].suit == hand[4].suit

Answer 6

检查一对并返回一个布尔值几乎没用。您需要检查从最高到最低的手（同花顺，4种，满屋，同花顺，直线等等）并创建一种排名的方法，以便您可以确定获胜者。在我看来，这并非微不足道。

Answer 7

非常规，但简洁：

import fj.P;
import fj.data.Stream;
import static fj.P2.untuple;
import static fj.pre.Equal.intEqual;

public Stream<Integer> pairs(Stream<Integer> hand) {
  return hand.apply(hand.map(P.<Integer, Integer>p2()))
             .filter(untuple(intEqual.eq()))
             .map(P1.<Integer>__1());
}

Get the imported libraries here

Answer 8

德州扑克扑克游戏评估员的完整源代码可以在这里找到：

http://www.advancedmcode.org/poker-predictor.html

它是为matlab构建的，GUI id是m编码的，但计算引擎是c ++。

它允许赔率和概率计算。在我的2.4Ghz笔记本电脑上，它可以在0.3秒内处理100000个10人游戏计算。

准确的实时计算机:-)

需要帮助确定扑克牌（一对）

8 个答案: