麻将算法之 ------ 胡牌算法

麻将数据牌集合

private int[] cardDataArray =
        {
        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 1 2 3 4 5 6 7 8 9
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 17 18 19 20 21 22 23 24 25
        0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 33 34 35 36 37 38 39 40 41
        0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //番子        49 50 51 52 53 54 55
        //0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,//花
        };

思路 ：麻将胡牌算法为3n*2(其中2为将牌、3n为顺子或者刻子)
1、首先查找所有可以作为将牌的牌。用剩余的牌来判断是否是可以胡的。
2、剩余的牌打上断点、用数量作为值来判断是否符合顺子或者刻子的算法。
3、符合返回true 不符合返回false.

代码如下

 // cbHandCard 为自己的手牌   cacheCard 为别人打得牌或者自摸得到的牌
 public bool huLegal(int cacheCard, int[] cbHandCard)
 {
 //获取手牌数组长度
 int first = cbHandCard.Length;    

 // 判断自己手牌的张数  mianNeed = 0 表示玩家剩余一张牌、不需要去判断将牌
 int mianNeed = NeedMain(cbHandCard);

 //新建集合、将所有的牌存入进去、来判断是否可以胡
 int[] card = new int[first + 1];
 for (int i = 0; i < first; i++)
 {
     card[i] = cbHandCard[i];
 }
 card[first] = cacheCard;
 SortCardList(card); //排序

 if (mianNeed == 0)
 {
   //表示玩家只剩余一张牌（只需判断和另外一张牌是否相等）
    if (cbHandCard[0] == cacheCard) return true;
    else return false; 
 }
 else
 {
   //手中牌不符合胡牌规则 3n*2
   if ((first + 1) % 3 != 2) return false;
   else
   {
       //提取出所有可能为将的牌。其余长度用0补全
       int[] jiangs = getJiang(card, first + 1);

       //去除将牌  mians 是去除掉将牌后的牌 （因为可能有多个将牌 所以为集合）
       List<int[]> mians = quJiangArrs(card, jiangs, first + 1);


      //当前去除将牌后牌的长度
      int size = mians.Count;
      //将去除将牌后分段是否符合可胡牌型的bool值
      bool[] ones = new bool[size];
      //每一个断点的所有牌的集合
      int[] breaks;


     for (int i = 0; i < size; i++)
     {
         //根据打的断点 获取到第一个长度的所有牌型
         breaks = getBreaks(mians[i], first - 1);

         if (breaksCheck(breaks, breaks.Length))
         {
         //获取到的牌不符合3n的格式、直接为false
          ones[i] = false;
         }
         else
         {
            //如果断点断的牌符合顺子或者刻字（3n）的格式
            int[] miansparts = allParts(mians[i], breaks);

            ones[i] = finalHu(miansparts, miansparts.Length);
          }
       }

        for (int i = 0; i < size; i++)
        {
           if (ones[i]) return true;
        }

     }
   }

       return false;
}

接下来为上个方法所用到的一些方法

    /// 是否需要将牌（玩家剩余一张牌是不需要）
    int NeedMain(int[] cbHandCard)
    {
        int last = cbHandCard.Length;
        if (last <= 1)
        {
            return 0;
        }
        return 1;
    }



    /// 排序手中的牌
    public void SortCardList(int[] handCard)
    {
        List<int> sortTemp = new List<int>(handCard);
        sortTemp.Sort();
        for (int i = 0; i < sortTemp.Count; i++)
        {
            handCard[i] = sortTemp[i];
        }
    }




    /// 查找所有的将牌 
    int[] getJiang(int[] cbHandCard, int cbHandCardCount)
    {
        int[] arr = new int[cbHandCardCount];
        int count = 1;

        for (int i = 1; i < cbHandCardCount; i++)
        {
            if (cbHandCard[i] == cbHandCard[i - 1])
            {
                if (count == 1) arr[i - 1] = cbHandCard[i];
                count += 1;
            }
            else count = 1;
        }
        return arr;
    }





    /// 去除将牌、返回所有牌的情况（因为可能有多种牌做奖牌）、
    // List 集合中每一个索引对应的数组都是一种排列方式
    List<int[]> quJiangArrs(int[] card, int[] jiangs, int length)
    {
        List<int[]> list = new List<int[]>();

        for (int i = 0; i < length; i++)
        {
            if (jiangs[i] != 0)
            {
                int[] src = new int[length];
                int[] arr = new int[length - 2];
                for (int j = 0; j < length; j++)
                {
                    src[j] = card[j];
                }

                src[i] = 0x00;
                src[i + 1] = 0x00;

                SortCardList(src);
                Array.Copy(src, 2, arr, 0, length - 2);
                list.Add(arr);
            }
        }
        return list;
    }



    /// 查找去除将牌后的断点（没有连续的牌就是一个断点）
    /// 返回的数组为断点所在索引的集合 例如（3 4 5 7 8 9） 断点集合{0，3，6}
    int[] getBreaks(int[] cbHandCard, int cbHandCardCount)
    {
        int[] breaks = new int[22];//首位0
        int count = 1;
        for (int i = 1; i < cbHandCardCount; i++)
        {
            if ((cbHandCard[i] - cbHandCard[i - 1]) > 1)
            {
                breaks[count] = i;
                count += 1;
            }
        }
        breaks[count] = cbHandCardCount;


        int[] breakss = new int[count + 1];//首位0 尾位length

        for (int i = 0; i < count + 1; i++)
        {
            breakss[i] = breaks[i];
        }


        return breakss;


    }



     /// <summary>
    /// 断点后、检查所断的牌型是不是顺子或者刻子
    /// 手牌 3 4 5 7 8 9  -- 断点后  0  3  6  （将牌已被丢出）
    /// </summary>
    /// <param name="breaks">  breaks 为断点后 下标的集合</param>
    /// <param name="length"></param>
    /// <returns> false 表示断牌为顺子或者刻字  true表示不符合胡牌规则  </returns>
    bool breaksCheck(int[] breaks, int length)
    {

        for (int i = 1; i < length; i++)
        {
            if (breaks[i] % 3 != 0)
                return true;
        }
        return false;
    }




     /// <summary>
    /// 根据手牌和断点的数组 返回经过处理的牌型
    /// </summary>
    /// <param name="cbHandCard">  cbHandCard -- 去除将牌后的手牌</param>
    /// <param name="breaks">  breaks -- 标记断点后的索引</param>
    /// <returns></returns>
    int[] allParts(int[] cbHandCard, int[] breaks)
    {

        int partnum = breaks.Length - 1;  //断点个数

        int[] parts = new int[partnum];
        int[] arr;
        for (int i = 0; i < partnum; i++)
        {

            arr = new int[breaks[i + 1] - breaks[i]];

            for (int j = 0; j < breaks[i + 1] - breaks[i]; j++)
            {
                arr[j] = cbHandCard[breaks[i] + j];
            }

            // arr集合表示 去除将牌后的手牌根据断点分别放入的牌
            parts[i] = getWei(arr, arr.Length);
        }

        return parts;
    }

因为3n中的牌型的类型不确定。所以此处采取一种拆解法
举例 （五万、五万、五万、六万、七万、七万、八万、八万、九万）
因为此为连续的牌型、所以放入一个集合中、用牌的数量来表示 （3 1 2 2 1）
分析：取出三张牌 （3 1 2）来判断这三张牌中是否有三张相等的、如果有则去除首位 余 1 2 （后两位 2 1）
继续取出三张牌 （ 1 2 2） 三张都大于等于1 递减一 排除顺子 余 1 1 （后一位 1）
剩下三张（1 1 1） 可胡

以上思路代码实现

        /// <summary>
        /// 判断断点处理后的值是否符合规则
        /// </summary>
        /// <param name="cbCardWei"> 断点后经过处理的值 （例如 1 1 2 1 1） </param>
        /// <returns></returns>
        bool isMianPart(int cbCardWei)
        {
            int cache = cbCardWei;
            for (int i = 0; i < 9; i++)
            {
                cache = carryChange(cache);
                if (cache == 0) return true;
            }
            return false;
        }



 int carryChange(int cbCardWei)
           {

            int keyNum = 3;
            int result = cbCardWei;
            int weilength = (int)Mathf.Log10(cbCardWei) + 1;//位的长度

            int weihead = (int)(cbCardWei / Mathf.Pow(10, (weilength - keyNum)));//位的头部

            if (carry(weihead) != 0)
            {
                result = (int)(cbCardWei - (carry(weihead) * Mathf.Pow(10, (weilength - keyNum))));//位运算结果

            }//前三位拆分无结果拆前两位
            else
            {

                keyNum = 2;
                weihead = (int)(cbCardWei / Mathf.Pow(10, (weilength - keyNum)));

                if (carry(weihead) != 0)
                {
                    result = (int)(cbCardWei - (carry(weihead) * Mathf.Pow(10, (weilength - keyNum))));//位运算结果
                }//前两位拆分无结果只拆前一位
                else
                {

                    keyNum = 1;
                    weihead = (int)(cbCardWei / Mathf.Pow(10, (weilength - keyNum)));
                    if (carry(weihead) != 0)
                    {
                        result = (int)(cbCardWei - (carry(weihead) * Mathf.Pow(10, (weilength - keyNum))));//位运算结果
                    }//拆一位无结果则result结果不改变
                }
            }
            return result;
        }





               int carry(int key)
               {//进位
                switch (key)
               {
                case 3: return 3;
                case 4: return 3;

                case 31: return 30;
                case 32: return 30;
                case 33: return 33;
                case 44: return 33;

                case 111: return 111;
                case 112: return 111;
                case 113: return 111;
                case 114: return 114;

                case 122: return 111;
                case 123: return 111;
                case 124: return 111;

                case 133: return 111;
                case 134: return 111;

                case 141: return 141;
                case 142: return 141;
                case 143: return 141;
                case 144: return 144;

                case 222: return 222;
                case 223: return 222;
                case 224: return 222;

                case 233: return 222;
                case 234: return 222;
                case 244: return 222;

                case 311: return 300;
                case 312: return 300;
                case 313: return 300;
                case 314: return 300;

                case 322: return 300;
                case 323: return 300;
                case 324: return 300;

                case 331: return 330;
                case 332: return 330;
                case 333: return 333;
                case 334: return 333;

                case 341: return 330;
                case 342: return 330;
                case 343: return 330;
                case 344: return 333;

                case 411: return 411;
                case 412: return 411;
                case 413: return 411;
                case 414: return 414;

                case 422: return 411;
                case 423: return 411;
                case 424: return 411;

                case 433: return 411;
                case 434: return 411;

                case 441: return 441;
                case 442: return 441;
                case 443: return 441;
                case 444: return 444;

            }
              return 0;
          }