Question

我正在尝试创建一个手动评估器，它可以让我比较一只手是否优于另一只手。我知道关于这个主题的关于SO的许多其他帖子，但是现在它们中的许多都已经老了，并且链接不再链接到任何有用的东西。我现在能想到的唯一方法是手动检查每个不同的组合。例如检查任何套装的ace，如果不存在，则移动到下一个组合，例如直接冲洗然后4种，依此类推。然而，那么你如何将一对2s与一对3s进行比较，除非你给出了一些有趣的牌组合。但是，这很难手动完成。还有更好的方法吗？

Answer 1

为什么很难？

class Card{

String suite;
int value;
....
}
// ...if two combinations are equal, Do for both combinations
int power = 0;

for (Card card: combination){
power += card.getValue()
}
// and compare!

Answer 2

我会为每种类型的组合分离问题，并为名为ie的组合的特定出现分配一个整数。强度（因此5-4-3-2-A的同花顺是最弱的，而K-Q-J-10-9是最强的）。

我认为个别组合可以很好地处理。对于皇家同花顺，你按照他们的号码降序排序你的7张牌，并检查前5张牌是否是（A-K-Q-J-10）以及他们是否属于同一套牌。皇家同花顺的力量无限期。

对于同花顺，您可以通过套装对卡片进行分类，并检查您是否可以在卡片列表中移动4次而无需见证套装更改。 Flush的力量取决于它的最高价值卡。

这个想法的一个非常简短的模板：

   // main logic of who wins, note it doesn't handle when two players have the same
// combo with same strength
class HandComparator {
    public Player compare(Player player1, Player player2) {
        HandEvaluator handEvaluator = new HandEvaluator();
        Combination player1Combo = handEvaluator.evaluate(player1.hand);
        Combination player2Combo = handEvaluator.evaluate(player2.hand);

        if (player1Combo.type.equals(player2Combo.type)) {
            // note, strength is only taken into account if the two players have
            // the same combo (ie both has full house)
            if (player1Combo.strength < player2Combo.strength) {
                return player2;
            } else {
                return player1;
            }
        } else if (player1Combo.type.compareTo(player2Combo.type) < 0) {
            return player2;
        } else {
            return player1;
        }
    }
}

class Card {
    int suit;
    int number;
}

class Player {
    List<Card> hand;
}

// this is built by CombinationRecognisers. Note, that the member 'strength' is
// related to a specific combination, not all possible hands
class Combination {

    enum Type {
        ROYAL_FLUSH,
        STRAIGHT_FLUSH;
        // etc.
    }

    Type type;
    int strength;
}

// implement this for all combinations (ROYAL_FLUSH,STRAIGHT_FLUSH, etc)
interface CombinationRecogniser {
    public Combination evaluate(List<Card> hand);
}

/*
 * this class holds all CombinationRecognisers and iterates throught them. It
 * will stop the moment a combo has been found.
 */
class HandEvaluator {
    static List<CombinationRecogniser> recognizers = new ArrayList<CombinationRecogniser>();

    static {
        recognizers.add(new RoyalFlushRecogniser());
        recognizers.add(new StraightFlushRecogniser());
    }

    public Combination evaluate(List<Card> hand) {

        for (CombinationRecogniser recogniser : recognizers) {
            Combination combination = recogniser.evaluate(hand);
            if (combination != null) {
                return combination;
            }
        }
        return null;
    }
}

class RoyalFlushRecogniser implements CombinationRecogniser {

    @Override
    public Combination evaluate(List<Card> hand) {
        // code goes here that decides if the given hand is a valid royal flush
        return null; // of new Combination() if the given hand is a valid royal flush
    }

}

class StraightFlushRecogniser implements CombinationRecogniser {

    @Override
    public Combination evaluate(List<Card> hand) {
        // code goes here that decides if the given hand is a valid straight flush
        return null; // of new Combination() if the given hand is a valid royal flush
    }

}

如果为所有特殊组合实现CombinationRecogniser接口，则此代码实际上有效。一个例子：

Answer 3

我不知道这是否是最好的方法，但这可能是可能的，这都是手动的。

假设您已经拥有代码来确定玩家以这种格式拥有哪只牌：

22s, KKs, 98o, 11o

现在你有一个包含三个值的数组，例如：

["K", "K", "s"]

......和另一个阵列：

[9, 8, "o"]

你首先要把那些牌（比如同花顺，直线等）分类，以确定哪一只会赢（皇家同花顺总是赢）。在那些检查之后，你必须在阵列中进行一些检查。如果"K"高于9等，请检查它是否适合或不适合

你可以给他们这样的价值：

...
  8 = 8
  9 = 9
  10 = 10个
  J = 11
  Q = 12
  K = 13
  A = 14（或1）

然后与之比较。这是一个很难的算法，无需手动执行此类操作即可正确执行此操作。我希望有这方面经验的人能够回答我的错误或错误的步骤/想法。

Java 7卡扑克手评估员

3 个答案: