确定印度拉米手牌是否是获胜手牌-爪哇

Question

我正在寻找一个有效的解决方案来确定印度拉米牌中的一手牌是否获胜。印度拉米酒在混合方面与杜松子酒拉米酒相似。一个人可以混合相同花色的序列（直），也可以混合相同值的集合。序列和集合都应该至少包含3张牌。与金拉米不同，在印度拉米，一手牌由13张牌组成。一手赢牌应该包含至少两个序列，其中至少一个序列必须是纯序列。纯粹，我的意思是序列不应该在小丑（百搭牌）的帮助下制作。手的其余部分可以由有或没有小丑的序列和集合组成。注意：除了一副牌（52 2）中的2张扑克之外，还有一张牌中的随机牌用作扑克。例如，如果黑桃的5被随机选为小丑，那么套牌中其他套装的剩余3个5可以在2个普通小丑的基础上用作小丑。

以下是一些不使用小丑的有效赢牌示例：

• A、 K，Q，J（黑桃）| 2,3,4（红桃）| 2,2,2（黑桃，梅花，钻石）| 3,4,5（钻石）
• A、 K，Q，J，10（黑桃）| 4，5，6，7，8（梅花）| 9，9，9（钻石，梅花，黑桃）
• A、 K，Q，J，10,9,8,7,6,5（黑桃）| 4,3,2（黑桃）

下面是几个使用小丑赢得手牌的例子。假设6（黑桃）是从牌堆中随机挑选的小丑；所以剩下的6都可以当小丑用。

• A，K，Q，J（黑桃；纯序列）|7,7,7（方块，梅花，黑桃）|3,3,6（方块，梅花，梅花；与小丑一起设置）|A，2,6（梅花，梅花，红心）
• A，2,3（红桃）|4,5,6（红桃）|7,7,7（黑桃，梅花，方块，红桃）|8,6,10，小丑（黑桃，方块，黑桃；与小丑的顺序，6和一个普通小丑）

以下是一些无法获胜的例子：

• A、 2，小丑（红心）| 4,5，小丑（红心）| 7,7,7（所有套装）| 9,9,9（梅花、钻石、红心）（这不是有效的手牌，因为它不包含纯序列）

我希望这已经解释了什么是赢牌。以下型号代表一张卡片：

public class Card {

public final static int SPADES = 0,
        HEARTS = 1,
        DIAMONDS = 2,
        CLUBS = 3;

html" target="_blank">public final static int ACE = 1,
        JACK = 11,
        QUEEN = 12,
        KING = 13,
        JOKER = 0;

private final int suit;

private final int value;

public Card(int theValue, int theSuit) {
    value = theValue;
    suit = theSuit;
}

public int getSuit() {
    return suit;
}

public int getValue() {
    return value;
}

public String getSuitAsString() {
    switch ( suit ) {
        case SPADES:   return "Spades";
        case HEARTS:   return "Hearts";
        case DIAMONDS: return "Diamonds";
        case CLUBS:    return "Clubs";
        default:       return "??";
    }
}

public String getValueAsString() {
    switch ( value ) {
        case 1:   return "Ace";
        case 2:   return "2";
        case 3:   return "3";
        case 4:   return "4";
        case 5:   return "5";
        case 6:   return "6";
        case 7:   return "7";
        case 8:   return "8";
        case 9:   return "9";
        case 10:  return "10";
        case 11:  return "Jack";
        case 12:  return "Queen";
        case 13:  return "King";
        default:  return "JOKER";
    }
}

@Override
public String toString() {
    return getValueAsString().equals("JOKER") ? "JOKER" : getValueAsString() + "(" + getSuitAsString() + ")";
}

@Override
public boolean equals(Object card) {
    return suit == ((Card) card).getSuit() && value == ((Card) card).getValue();
}

}

private List<List<Card>> getSequences(List<Card> hand, int min) {
    List<List<Card>> sequences = new ArrayList<>();
    List<Card> sequence = new ArrayList<>();
    for(int i=1; i<hand.size(); i++) {
        if(hand.get(i).getSuit() == hand.get(i-1).getSuit() &&
                (hand.get(i).getValue() - hand.get(i-1).getValue()) == 1) {
            sequence.add(hand.get(i-1));
            if(hand.get(i).getValue() == 13) {
                int j = i;
                while(hand.get(j).getSuit() == hand.get(i).getSuit()) {
                    j--;
                    if(hand.get(j).getValue() == 1) {
                        sequence.add(hand.get(j));
                    }
                }
            }
            if(i == hand.size() -1) {
                sequence.add(hand.get(i));
                sequences.add(sequence);
            }
        } else {
            sequence.add(hand.get(i-1));
            if(sequence.size() >= min) {
                sequences.add(sequence);
            }
            sequence = new ArrayList<>();
        }
    }
    return sequences;
}

private List<List<Card>> getSets(List<Card> hand, int min) {
    List<List<Card>> sets = new ArrayList<>();
    List<Card> set = new ArrayList<>();
    for(int i=1; i<hand.size(); i++) {
        if(hand.get(i).getValue() != joker.getValue()) {
            if(hand.get(i).getValue() == hand.get(i-1).getValue()) {
                set.add(hand.get(i-1));
                if(i == hand.size() -1) {
                    set.add(hand.get(i));
                }
            } else {
                set.add(hand.get(i-1));
                if(set.size() >= min) {
                    sets.add(set);
                }
                set = new ArrayList<>();
            }
        }
    }
    return sets;
}

我不认为这是寻找序列和集合的最优雅的方式。因此，我欢迎任何关于如何改进它的建议。但我真正需要的是我下一步该做什么？集合和序列之间可能有重叠。例如，在以下卡的情况下：

• A、 2,3（黑桃）| 4,4,4（黑桃、梅花、红桃）我的getSequences函数将返回一个，2,3,4（黑桃）序列。我应该避免在我的序列中包含4个黑桃，以便在4个黑桃中使用

请建议如何有效地决定胜局。

附言：在决定胜出一手牌时，玩家手中将有14张牌。融合13张牌后，第14张牌将作为结束牌丢弃。

Answer 1

我已经实现了Rummikub的java版本（一个具有类似约束的游戏）。

我的方法是给每张卡一个隐藏的整数属性（一个素数）。

然后，每个有效的meld可以唯一地表示为一个整数。可以预先计算出构成有效融合的精确整数，并将其放入集合中

检查一只手是否只包含有效的混合，然后简化为检查给定的长是否可以写成给定数字集的乘积。（可以使用递归和动态编程）

具体例子（1）：

• 红桃王牌=

设置

如果手（值=60），那么我们知道它包含两个有效的混合。

具体实例（2）

• 球杆的1=2
• 2的梅花=3
• 球杆的3=5
• 4的梅花=7
• 4的红桃=179
• 4的钻石=181

已知有效的MELD={30，210，226793，…}

手的价值=6803790

简易（递归）算法：

>

6803790可被30整除

（6803790 / 30 = ) 226793可被226793整除

递归算法断定这是一个有效的分支

备选方案

6803790可被210整除

递归算法在这里结束分支

如果您需要能够处理手牌的某些部分并不总是有效meld的一部分的情况，您可能希望研究线性代数。