骰子问题（葫芦和顺子识别）

Question

我正在做一个骰子游戏。我有 5 个骰子，其中有所有值，我需要确定它们是否组成葫芦（一个 3 个，另一个 2 个）、小顺子（1-4、2-6 或 3-6）或大顺子（1-5、2-6）。

也许解决这个问题的最佳方法似乎是使用正则表达式。

有谁知道我将如何在正则表达式中表示这些规则？

或者，如果您能提供更好的解决方案，我将不胜感激。

示例：

• 葫芦 = 44422 或 11166 或 12212 等。
• 小顺子 = 12342 或 54532 等。
• 大顺子 = 12345 或 52643 等。

编辑
更改措辞以强调这是我缺乏经验的观点。

我知道如何使用代码来实现这一点，但这似乎是一个冗长的解决方案，我想知道是否有更简单的方法。

Answer 1

我会对所有数字进行递减排序，然后对每个值进行一些线性标准匹配，无论它是 int[] 还是字符串。

Answer 2

不了解 C#，但在脚本语言中我会采用正则表达式路线。对于每一边，计算它在组合中出现的次数并将结果连接在一起。例如，对于组合 12342，计数器字符串将为 121100。然后将计数器字符串与这些模式进行匹配：

/5/ = 五个相同的
/4/ = 四种
/20*3|30*2/ = 满堂彩
/1{5}/ = 大顺子
/[12]{4}/ = 小顺子
/3/ = 三个相同的
/2[013]*2/ = 两对
/2/ = 一对

Answer 3

您始终可以执行 LINQ 聚合查询并计算相同卡片的数量。这将类似于（无法测试它）：

var query =  from card in hand
             group card by card into groupedCards
             select new { Card = groupedCards.Key, Count = groupedCards.Count() };

这样您就可以轻松地知道您是否正在处理可能的顺子（或根本没有），一对，三元组等。

我不是 LINQ 专家和我目前无法测试这段代码，所以我不确定它是否会按原样编译，但它可能会帮助您或让您了​​解如何解决手头的问题。

例如：

1. if count query = 5 ：我们正在处理空手牌、同花或顺子 =>运行特定的同花/顺子逻辑。

2. if count query = 4：我们正在处理单个对。

3. if count query = 3 ：我们正在处理双对或三元组 => if max count =3 then Triple

4. if count query = 2 ：我们正在处理葫芦/扑克。如果最大计数 = 4，则扑克

Answer 4

我不会评论您如何查找结果，而是评论您如何存储结果以供以后查找。

由于只有 46656 种可能的组合，并且一个字节可以存储最终的手牌强度，因此这个问题比扑克手牌问题容易得多。

您可以有一个查找表，其中包含作为索引的手牌并与该手牌的结果相关联（某些手牌可以有多个结果）。每个字节可以将所有手型存储为二进制表示形式（希望，如果不使用短整型）。

您获得的每个数字（例如 66655 - 满堂彩）都是以六为基数 (1-6) 的数字，将其转换为以 10 为基数的数字以获得查找表中的索引。

它将需要大约 46656 字节（+ CPU 对齐），并且可以放入 CPU L2 缓存。速度将是巨大的，因为您需要做的唯一操作是转换数基，以及提取手部力量的二进制或运算。

你会错过的是一手牌的真正力量。例如。 66655 比 66644 更好。你可以很容易地弄清楚这一点 - 你将需要一个更大的类型来存储结果:)

Answer 5

我决定自己尝试一下，最终没有使用正则表达式——我想也许由于搜索所需的简单性，正则表达式会增加比它们节省的更多的复杂性。不过，我对另一个答案使用了类似的逻辑：计算每个数字的数量，并以此为基础进行所有评分：

  enum RollScoreType
  {
     HighDie,
     Pair,
     TwoPair,
     ThreeOfAKind,
     SmallStright,
     PairSmallStriaght,
     FullHouse,
     LargeStraight,
     FourOfAKind,
     FiveOfAKind
  }

  struct RollScore
  {
     public RollScoreType type;
     public byte highestDie;
     public byte nextHighestDie;
     public RollScore(RollScoreType type, byte highest, byte next)
     {
        this.type = type;
        this.highestDie = highest;
        this.nextHighestDie = next;
     }
     public override string ToString()
     {
        return string.Format("{0} {1} {2}", type, highestDie, nextHighestDie);
     }
  }

  static RollScore GetDiceScore(string input)
  {
     char[] dice = input.ToCharArray();
     byte[] diceCount = new byte[6];

     for (int i = 0; i < dice.Length; i++)
        diceCount[int.Parse(dice[i].ToString())-1]++;

     if (Array.IndexOf(diceCount, (byte)5) >= 0)
        return new RollScore(RollScoreType.FiveOfAKind, (byte)(Array.IndexOf(diceCount, (byte)5) + 1), 0);
     else if (Array.IndexOf(diceCount, (byte)4) >= 0)
        return new RollScore(RollScoreType.FourOfAKind, (byte)(Array.IndexOf(diceCount, (byte)4) + 1), (byte)(Array.IndexOf(diceCount, (byte)1) + 1));
     else if (Array.IndexOf(diceCount, (byte)3) >= 0)
     {
        byte three = (byte)(Array.IndexOf(diceCount, (byte)3) + 1);
        if (Array.IndexOf(diceCount, (byte)2) >= 0)
        {
           byte pair = (byte)(Array.IndexOf(diceCount, (byte)2) + 1);
           return new RollScore(RollScoreType.FullHouse, Math.Max(pair, three), Math.Min(pair, three));
        }
        else
           return new RollScore(RollScoreType.ThreeOfAKind, three, (byte)(Array.LastIndexOf(diceCount, (byte)1) + 1));
     }
     else if (Array.IndexOf(diceCount, (byte)2) >= 0)
     {
        byte pair = (byte)(Array.IndexOf(diceCount, (byte)2) + 1);
        byte highPair = (byte)(Array.LastIndexOf(diceCount, (byte)2) + 1);
        if (highPair != pair)
           return new RollScore(RollScoreType.TwoPair, highPair, pair);
        else
        {
           byte lowMissingDie = (byte)Array.IndexOf(diceCount, (byte)0);
           byte highMissingDie = (byte)Array.LastIndexOf(diceCount, (byte)0);
           switch (lowMissingDie)
           {
              case 0:
                 if (highMissingDie == 5)
                    return new RollScore(RollScoreType.PairSmallStriaght, 5, 4);
                 if (highMissingDie == 1)
                    return new RollScore(RollScoreType.PairSmallStriaght, 6, 5);
                 break;
              case 4:
                 return new RollScore(RollScoreType.PairSmallStriaght, 4, 3);
           }
           return new RollScore(RollScoreType.Pair, pair, (byte)(Array.LastIndexOf(diceCount, (byte)1) + 1));
        }
     }
     byte missingDie = (byte)Array.IndexOf(diceCount, (byte)0);
     switch(missingDie)
     {
        case 0:
           return new RollScore(RollScoreType.LargeStraight, 6, 5);
        case 1:
           return new RollScore(RollScoreType.SmallStright, 6, 5);
        case 4:
           return new RollScore(RollScoreType.SmallStright, 4, 3);
        case 5:
           return new RollScore(RollScoreType.LargeStraight, 5, 4);                  
        default:
           return new RollScore(RollScoreType.HighDie, 6, (byte)(Array.LastIndexOf(diceCount, (byte)1, 3) + 1));
     }
  }

令我惊讶的是，我发现在 5 骰子掷骰子中，小顺子和大顺子的概率是相等的。是这样吗！？

编辑：已修复；我发现，当我将包含一对的小顺子包括在内时，小顺子的概率会显着上升。

当我想到这一点时，一对和一个小顺子可能应该使用该对作为最高骰子，并将顺子中的最高数字作为下一个最高数字（为了正确比较两个都是一对和小顺子的骰子） ）。如果是这样，我将用以下代码替换处理 PairSmallStraight 的代码块：

           switch (lowMissingDie)
           {
              case 0:
                 if (highMissingDie == 5)
                    return new RollScore(RollScoreType.PairSmallStriaght, pair, 5);
                 if (highMissingDie == 1)
                    return new RollScore(RollScoreType.PairSmallStriaght, pair, 6);
                 break;
              case 4:
                 return new RollScore(RollScoreType.PairSmallStriaght, pair, 4);
           }

Answer 6

您可以尝试将您的值放入列表中。这将使您能够快速对值进行排序。如果你添加这些值，就会给你带来帮助。 111AA = 29 和 222KK = 30。只是一个想法。

Answer 7

这是我的代码：

    public static int   CalculateTotalOfSingles       (int pipNumber)
    {
        //
        var myScore = 0;
        foreach (var myDie in Roll5Player.MyHand.Dice)
        {
            {   if (myDie.Pips == pipNumber)
                myScore+= pipNumber;
            }
        }
        //
        return myScore;
    }
    public static int   CalculateDicePips       ()
    {
        //
        var myScore = 0;
        foreach (var myDie in Roll5Player.MyHand.Dice)
        {
            {myScore += myDie.Pips;
            }
        }
        //
        return myScore;
    }
    //
    //
    //
    public static int   CalculateTotalOfAllSingles    (int pipNumber)
    {
        //
        var myScore = 0;
        for (int i = 1; i <= 6; i++)
        {
            myScore += pipNumber;
        }
        //
        return myScore;
    }
    public static bool  CalculateIsNOfaKind     (int count)
    {
        //
        for (var index = 1; index <= 6; index++)
        {
            var cntr = 0;
            foreach (var myDie in Roll5Player.MyHand.Dice)
            {
                if (myDie.Pips == index)
                    cntr++;
            }
            //
            if (cntr == count)
            {
                return true;
                ;
            }
        }
        //
        return false;
    }
    public static int   CalculateNOfaKind       (int count  )
    {
        //
        var myScore = 0;
        for (var index = 1; index <= 6; index++)
        {
            var cntr = 0;
            foreach (var myDie in Roll5Player.MyHand.Dice)
            {
                    if (myDie.Pips == index)
                        cntr++;
            }
            //
            if (cntr >= count)
            {   myScore = CalculateDicePips();
                return myScore;
                ;
            }
        }
        //
        return myScore;
    }
    /// 
    public static int   CaluclateFullHouse      (           )
    {
        // 
        var myScore = 0;
        var cntr    = new int[6];
        for (var index = 1; index <= 6; index++)
        {
            foreach (var myDie in Roll5Player.MyHand.Dice)
            {
                if (myDie.Pips == index)
                    cntr[index-1]++;
            }
        }

        //
        var boolCondA = false;
        var boolCondB = false;
        foreach (var i in cntr)
        {
            if (i == 3)
            {boolCondA = true;
                break;
            }
        }
        if (boolCondA)
        {
            foreach (var i in cntr)
            {
                if (i == 2)
                {boolCondB = true;
                    break;
                }
            }
        }


        //
        if (boolCondB ) 
            myScore = CalculateDicePips();



        //
        //
        //
        return myScore;
    }
    public static int   CaluclateStraights      (int straightCount, int score)
    {
        // 
        var tempPip     = 0;
        var myScore     = 0;
        var isFirstIteration = true;
        var cntr = 0;
        int[] sortedDice = new int[5];
        var sortedDiceLise = new List<int>();


        foreach (var myDie in Roll5Player.MyHand.Dice)
        {
            sortedDiceLise.Add(myDie.Pips);
        }
        sortedDiceLise.Sort();







        foreach (var myDie in sortedDiceLise)
        {
            //
            //
            if (!isFirstIteration)
            {
                if (myDie == tempPip + 1)
                    cntr++;
            }
            //
            isFirstIteration = false;
            tempPip = myDie;
        }





        if (cntr == straightCount - 1)
        {myScore = score;
        }

        //
        //
        //
        return myScore;
    }

    public static int   CalculateYahtzee        ()
    {
        //
        for (var index = 1; index <= 6; index++)
        {
            var cntr = 0;
            foreach (var myDie in Roll5Player.MyHand.Dice)
            {
                if (myDie.Pips == index)
                    cntr++;
            }
            //
            if (cntr == 5)
            {
                return 50;
                ;
            }
        }
        //
        return 0;
    }