地方麻将吉林过蛋玩法算法

最新推荐文章于 2024-09-21 16:35:48 发布
最新推荐文章于 2024-09-21 16:35:48 发布
阅读量7.1k 收藏 1
点赞数
分类专栏： 算法，数据 文章标签： 算法 地方棋牌 吉林过蛋
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013422739/article/details/77530233
版权

最近在做地方棋牌游戏，发现有的地方棋牌玩法很独特，比如吉林的过蛋玩法 。先贴出代码，后面在做介绍。算法可鞥不是最优解，欢迎大神拍砖，交流QQ:850912758。

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
/// <summary>
/// 判断  过蛋/补蛋  牌逻辑 类
/// 输入：手牌中的蛋牌
/// 输出：可过蛋牌的 所有 排列组合
/// 方法：
///           1. 无 混 ：
///                      所有蛋牌排列组合
///           2.有混：
///           2.1.一张混牌所有排列组合
///           2.2 两张混牌所有排列组合
/// </summary>
public class EggCtro
{
    private static EggCtro _instance = null;

    List<int> InputEggCard;//输入的手牌
    private List<List<int>> OutPutEggs = new List<List<int>>();//输出的的过蛋牌 


    private List<List<int>> CurEggCardList ;//当前碰牌区 的蛋牌列表 
    private List<int> AddEggCardList = new List<int>();//补蛋  单张蛋牌集合 （输出的补蛋集合）


     int CardHun = 11;//混牌
    //标准蛋牌 
    int[] Egg1 = { 1, 11, 21 };
    int[] Egg2 = { 9, 19, 29 };
    int[] Egg3 = { 35, 36, 37 };
    int[] Egg4 = { 31, 32, 33, 34 };
    List<int[]> AllEggs = new List<int[]>();
    //标准蛋牌

    public static EggCtro Instance
    {
        get
        {
            if (_instance == null)
                _instance = new EggCtro();
            return _instance;
        }
    }

    #region 过蛋

    void InIt()
    {
        AllEggs.Clear();
        AllEggs.Add(Egg1);
        AllEggs.Add(Egg2);
        AllEggs.Add(Egg3);
        AllEggs.Add(Egg4);
    }

   /// <summary>
   /// 获取可过蛋牌列表
   /// </summary>
   /// <param name="handCards"></param>
   /// <returns></returns>
    public List<List<int>> GetEggCardValues(List<int> handCards)
    {
        OutPutEggs.Clear();
        InputEggCard = handCards;
        InIt();
        NoHunEgg();

        //手牌 中的蛋牌 分类
        List<int> CurYaoEggCard = new List<int>();
        List<int> CurJiuEggCard = new List<int>();
        List<int> CurZFBEggCard = new List<int>();
        List<int> CurFengEggCard = new List<int>();

        if (IsHandHunCard())
        {
            int hunCount = GetHunCount();
            RemoveHunCard();
            DistinctCard();
            //找出当前手牌 每种蛋牌类型的 一张混牌组合
            foreach (int item in InputEggCard)
            {
                if (item == 1||item == 21) { CurYaoEggCard.Add(item); }
                else if (item == 9 || item == 19 || item == 29) { CurJiuEggCard.Add(item); }
                else if (item == 31 || item == 32 || item == 33 || item == 34) { CurZFBEggCard.Add(item); }
                else if (item >= 35 || item == 36 || item == 37) { CurFengEggCard.Add(item); }
            }
            if (hunCount == 1)
            {
                //一个混 
                //蛋牌组 大于两张 ，才可以配合一张混牌组成蛋牌 
                AddOutPutThree(CurYaoEggCard);
                AddOutPutThree(CurJiuEggCard);
                AddOutPutThree(CurZFBEggCard);
                AddOutPutThree(CurFengEggCard); //风牌 四张不同牌 时的多种 排列组合

            }
            else if (hunCount >= 2)
            {
                //一个混 
                //蛋牌组 大于两张 ，才可以配合一张混牌组成蛋牌 
                AddOutPutThree(CurYaoEggCard);
                AddOutPutThree(CurJiuEggCard);
                AddOutPutThree(CurZFBEggCard);
                AddOutPutThree(CurFengEggCard); //风牌 四张不同牌 时的多种 排列组合
                //两个混  
                //可以跟每一张蛋牌组合 成蛋
                AddEggCard(CurYaoEggCard);
                AddEggCard(CurJiuEggCard);
                AddEggCard(CurZFBEggCard);
                AddEggCard(CurFengEggCard);
            }

        }
        return OutPutEggs;
        //ShowLog();
    }
    // 两混 添加提示 蛋牌 列表
    private void AddEggCard(List<int> CurYaoEggCard)
    {
        foreach (int item in CurYaoEggCard)
        {
            if (item == CardHun)//不能三个幺鸡
                continue;
            List<int> tempEgg = new List<int>();
            tempEgg.Add(item);
            tempEgg.Add(CardHun);
            tempEgg.Add(CardHun);
            OutPutEggs.Add(tempEgg);
        }
    }

    //一个混 三张 牌加入
    private void AddOutPutThree(List<int> HandEggCards)
    {
        if (HandEggCards.Count == 2)//两张牌 直接+混
        {
            HandEggCards.Add(CardHun);
            OutPutEggs.Add(HandEggCards);
        }
        else if (HandEggCards.Count >= 3)
        {
            List<int[]> tempEggList = Arrage(HandEggCards, 2); //三选二 排列 / 四选二 排列组合
            foreach (int[] item in tempEggList)
            {
                List<int> egg = item.ToList();
                egg.Add(CardHun);
                OutPutEggs.Add(egg);
            }
        }
    }
    //无混 排列组合
    public void NoHunEgg()
    {

        InputEggCard.Sort();
        //包含标准 蛋牌
        foreach (int[] egg in AllEggs)
        {
            List<int> same = ExistsEggType(egg);
            int sameCount = same.Count;
            if (sameCount == 3)
            {
                OutPutEggs.Add(same);
            }
            else if (sameCount == 4)
            {
                //完整风牌
                List<int[]> fengEgg = Arrage(same.ToList<int>(), 3);//4 选3 排列组合
                foreach (int[] item in fengEgg)
                {
                    OutPutEggs.Add(item.ToList<int>());
                }
            }
        }


    }
    void ShowLog()
    {
        string str = "";
        foreach (List<int> item in OutPutEggs)
        {
            str += " 【";
            foreach (int card in item)
            {
                str += card + " ";
            }
            str += " 】";
        }
        Debug.Log("输出蛋牌为：" + str + "             " + OutPutEggs.Count);
    }
    /// <summary>
    /// 是否包含标准蛋牌（风牌 三张组合例外）
    /// </summary>
    /// <param name="egg">标准蛋牌</param>
    List<int> ExistsEggType(int[] egg)
    {
        int eggCount = 0;
        List<int> tempEgg = new List<int>();
        for (int i = 0; i < egg.Length; i++)
        {
            if (InputEggCard.Exists(o => o == egg[i]))
            {
                eggCount++;
                tempEgg.Add(egg[i]);
            }
        }
        return tempEgg;
    }
    /// <summary>
    /// 手牌中是否包含混牌
    /// </summary>
    /// <returns></returns>
    bool IsHandHunCard()
    {
        return InputEggCard.Exists(o => o == CardHun);
    }
    //混牌数量
    int GetHunCount()
    {
        return InputEggCard.Count(delegate (int item) { return item == CardHun; });
    }
    //移除混牌 的手牌列表
    void RemoveHunCard()
    {
        int count = GetHunCount();
        for (int i = 0; i < count; i++)
        {
            InputEggCard.Remove(CardHun);
        }
    }
    //去除重复牌
    void DistinctCard()
    {
        List<int> result = InputEggCard.Distinct().ToList();//去重复
    }
    //M选N 排列组合
    List<int[]> Arrage(List<int> input, int _n)
    {
        //排列算法
        List<int> inputValue = input;
        int n = _n;
        var result = inputValue.Select(x => new int[] { x });
        for (int i = 0; i < n - 1; i++)
        {
            result = result.SelectMany(x => inputValue.Where(y => y.CompareTo(x.First()) < 0).Select(y => new int[] { y }.Concat(x).ToArray()));
        }
        List<int[]> resultList = new List<int[]>();
        foreach (int[] item in result)
        {
            resultList.Add(item);
        }
        return resultList;
    }

    #endregion





    #region 补蛋

    /// <summary>
    ///  找出手牌中可以补蛋的牌！
    /// </summary>
    /// <param name="curHandCards">当前手中蛋牌</param>
    /// <param name="yetEggs">已过蛋牌</param>
   public List<int> AddEgg(List<int> curHandCards,List<List<int>> yetEggs)
    {
        CurEggCardList = yetEggs;
        InputEggCard = curHandCards;
        if (CurEggCardList.Count == 0)
        {
            return null;
        }
        if (InputEggCard.Count == 0) {
            return null;
        }
        AddEggCardList.Clear();



        ////先判断蛋牌区 无 混牌情况 
        //再判断蛋牌区 有 混牌情况 
        //如果是 替换 幺鸡 的蛋牌 ，需要将幺鸡替换掉 并 加到头像下 +1
        foreach (int handCard in InputEggCard)
        {
            if (handCard == CardHun)
            {
                AddEggCardList.Add(handCard);//幺鸡 直接加入
                continue;
            }
        }
        //无混 蛋牌
        foreach (List<int> egg in CurEggCardList)
        {
            foreach (int card in egg)
            {
                int[] eggValue = GetEggType(card);

                foreach (int handCard in InputEggCard)
                {
                    foreach (int eggCard in eggValue)
                    {
                        if (eggCard == handCard && eggCard != CardHun)
                            AddEggCardList.Add(handCard);//手牌 里有已过蛋牌值 
                    }
                }
                break;
            }
        }

        //有混 蛋牌
        List<int[]> hunEggs = GetHunEggValue();
        foreach (int[] hunEgg in hunEggs)
        {
            List<int> insteadValue = GetHunEggInstead(hunEgg);
            List<int> handEggValue = InputEggCard.Intersect(insteadValue).ToList();//手牌里是否有被混取代的牌值
            if (handEggValue.Count > 0)
                AddEggCardList.AddRange(handEggValue);//得到 被混 取代的蛋牌值
        }


        string eggStr = "";
        foreach (int item in AddEggCardList)
        {
            eggStr += "     " + item.ToString();
        }
        Debug.LogError("可补蛋的牌：" + eggStr);


        return AddEggCardList;
    }


    /// <summary>
    /// 获取牌所属蛋牌型
    /// </summary>
    /// <param name="cardValue">牌值</param>
    /// <returns></returns>
   public int[] GetEggType(int cardValue)
    {
        int[] Eggs = null;
        foreach (int[] eggs in AllEggs)
        {
            foreach (int card in eggs)
            {
                if (cardValue == card)
                {
                    Eggs = eggs;
                }
            }
        }
        return Eggs;
    }
    /// <summary>
    /// //获取hun 蛋牌 中被混牌取代的值
    /// </summary>
    /// <param name="egg">含混蛋</param>
    /// <returns></returns>
    List<int> GetHunEggInstead(int[] egg)
    {
        List<int> tempValues = new List<int>();
        tempValues.Clear();

        List<int> NoHunValue = GetNoHunValue(egg);//获得 含混蛋牌中 不是混的 牌值 
        int cardValue = NoHunValue[0];//根据这个牌值 判断 所属 蛋牌类型 
        int[] typeEgg = GetEggType(cardValue);//获得 该蛋牌的 标准值 
        List<int> typeEggList = typeEgg.ToList();

        //和标准蛋牌比较，得出混牌代替的牌值 
        tempValues = typeEggList.Except(NoHunValue).ToList();//除什么之外？     Except  差集       Intersect交集      Union并集
        return tempValues;
    }

    /// <summary>
    /// 获取含混蛋牌 中的 非混牌值
    /// </summary>
    /// <returns>含混牌的 蛋</returns>
    List<int> GetNoHunValue(int[] hunEgg)
    {
        List<int> values = new List<int>();
        values.Clear();
        foreach (int eggCard in hunEgg)
        {
            if (eggCard != CardHun)
            {
                values.Add(eggCard);
            }
        }
        return values;
    }
    //获取包含 混牌 的蛋
    List<int[]> GetHunEggValue()
    {

        List<int[]> YiTiaoEggs = new List<int[]>();
        YiTiaoEggs.Clear();
        foreach (List<int> egg in CurEggCardList)
        {
            bool isHun = IsHunCard(egg);
            if (isHun)
            {
                int[] HunEgg = egg.ToArray();
                YiTiaoEggs.Add(HunEgg);
            }
        }
        return YiTiaoEggs;
    }
    //是否包含混牌
    bool IsHunCard(List<int> eggs)
    {
        foreach (int card in eggs)
        {
            if (card == CardHun)
            {
                return true;
            }
        }
        return false;
    }




    /// <summary>
    /// //获得 已 过蛋的 牌值
    /// </summary>
    /// <param name="cardValue"></param>
    /// <returns></returns>
    public List<int> GetAsAddEgg(int cardValue)
    {
        int[] eggType = EggCtro.Instance.GetEggType(cardValue);
        foreach (List<int> item in CurEggCardList)
        {
            foreach (int eggCard in item)
            {
                foreach (int typeCard in eggType)
                {
                    if (eggCard != 11 && eggCard == typeCard)
                    {
                        return item;
                    }
                }
            }
        }
        return null;
    }

    /// <summary>
    /// 替换 List <int> 值
    /// </summary>
    /// <param name="item"></param>
    /// <param name="curValue"></param>
    /// <param name="repValue">被替换的值</param>
    public  void ReplaceListValue(ref List<int> item, int curValue, int repValue)
    {
        int index = item.FindIndex(delegate (int i) { return i == curValue; });
        if (index < item.Count)
            item[index] = repValue;
    }
    /// <summary>
    /// 获得列表中大于1个的 重复组
    /// </summary>
    /// <param name="listValue"></param>
    /// <returns>(Dic<值-个数>)</returns>
    public  Dictionary<int, int> GetListRepitGroup(List<int> listValue)
    {
        //重复组
        Dictionary<int, int> RepetGroup = new Dictionary<int, int>();
        var result = from r in listValue
                     group r by r into g
                     where g.Count() > 1
                     select g;
        //遍历分组结果集
        foreach (var item in result)
        {
            foreach (int u in item)
            {
                RepetGroup.Add(u, item.Count<int>());
                Debug.Log(u + "       " + item.Count<int>());
                break;
            }
        }
        return RepetGroup;
    }
    #endregion


}
关大弓
关注
专栏目录
麻将游戏AI源代码
05-11
麻将游戏源代码，WINDOWS平台可编译运行的C/C++代码，包含必要资源，实现了人机对战
在HTML中在charset属性是什么意思
热门推荐
扬蛋儿
09-11 1万+
charset：规定 HTML 文档的字符编码； 我们常见的 &lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8"&gt; 常见的字符编码有 gb2312、 gbk、 unicode、 utf-8。 各个字符编码含义： gb2312：代表国家标准第2312条，其中是不包含繁体的（虽然咱们不怎么使用...
php麻将游戏源码,麻将游戏源代码 - 源码下载|游戏|源代码 - 源码中国
weixin_39618121的博客
03-12 4553
CMajiangGame.exeGameRes Readme.txtImages......\E_SAI.jpg......\E_XI.jpg......\E_YUYE.jpg......\HupaiTable.JPG......\MJ.jpg......\open1.jpg......\OPen2.jpg......\open3.jpg......\Start1.JPG......\Start2...
网络麻将的宝牌设计
weixin_33962923的博客
01-18 252
今天在帮客户改东北乾安的麻将，乾安麻将的宝牌比效复杂，需求如下：6.1 宝牌：可以替代任何牌的“万能牌”。6.2 宝牌产生：牌墙中的最后一张牌为“宝”牌。6.3 宝牌不能查看。6.4 换宝：宝牌被宝杠以后，牌墙中倒数第2张牌为宝牌。6.5 用户听牌后才能使用宝牌。 开始搞了，首选给宝牌定一个变量：看了一下代码，直接把财神当宝牌用了。 首先在开始游戏的地方把宝牌重置。 在用户听牌的动作上加一个读...
农安麻将 宝蛋
Hero_Monkey的博客
10-11 2584
吉林省地区的麻将游戏的一种特殊规则：打宝。打宝：在用户听牌后，可以投掷一颗骰子，根据骰子点数，从牌墙尾部第一层拿出一张麻将，这张麻将叫做宝牌。选好宝牌后有两种胡牌形式，一种是宝牌加入到手牌后组成胡牌牌型，叫做对宝；另一种是摸牌摸到的麻将和这张宝牌相同，叫做摸宝。 农安麻将游戏中的宝蛋规则：用户听牌后，打到的宝牌麻将可以和玩家的手牌麻将或者组合麻将组成杠牌形式。 宝蛋规则的实现： （1）服务端
c++麻将胡牌算法，癞子胡牌算法
04-02
本项目主要探讨了如何使用C++语言实现麻将胡牌算法，包括普通胡牌规则以及特殊的“癞子”（也称为万能牌）胡牌规则。这里我们将深入解析这两种算法的核心原理。 首先，我们来看基础的麻将胡牌算法。麻将是一种四人...
内蒙古赤峰麻将 一口香地方玩法 房卡游戏全套源码.zip
08-10
【标题】"内蒙古赤峰麻将 一口香地方玩法 房卡游戏全套源码"揭示了这是一个专门针对内蒙古赤峰地区特色麻将游戏的源代码包。这款游戏的独特之处在于它采用了“一口香”这一地方规则，这在麻将游戏中是一种特殊的玩法...
麻将胡牌算法
02-03
各种语言的麻将胡牌算法。干货。 c++ c# lua go js麻将胡牌算法
麻将算法源码（任意癞子）
02-10
分享一个麻将胡牌算法，支持多癞子，自己对麻将胡牌的理解写的一套快速识别胡牌逻辑，核心逻辑500行代码，仅对同条万进行处理，字花牌不包含在内，易理解，1M次随机胡牌牌型大概3秒左右。原创分享，我的算法也许可以...
四川麻将胡牌算法
06-12
在编程领域，实现四川麻将的胡牌算法是一项有趣的挑战，它涉及到数据结构、算法设计以及逻辑推理。本篇将深入探讨如何通过递归算法来实现这一功能。 首先，我们需要理解四川麻将的基本规则。在四川麻将中，玩家通常...
Python爬取某猫投诉数据（含signature参数分析与算法还原）
吴秋霖的博客
09-15 1188
使用Python爬取某猫投诉的数据（包含加密参数分析与算法的还原）
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 408
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
【百日算法计划】：每日一题，见证成长（016）
码上一元
09-18 329
百日算法计划：环形链表
尊享面试100题
qq_71286244的博客
09-21 304
尊享面试100题
LeetCode 算法笔记-第 04 章 基础算法篇
artificiali的博客
09-18 450
什么是质数：大于1的中，除了1和它本身以外不再有其他的。
[ABC330E] Mex and Update
2301_80882026的博客
09-18 889
给定一个序列，支持单点修改，每次修改后输出全局mex。一个序列的mex定义为，序列中最小的没有出现过的非负整数。
代码随想录打卡Day39
最新发布
weixin_52151595的博客
09-21 214
今天是打家劫舍专题，三道题全都看了讲解，第一次做感觉确实是无从下手。。。不过了解了原理之后代码很快就写出来了。
双指针算法专题（2）
我要学编程的博客
09-16 1138
LeetCode刷题：有效三角形的个数、查找总价格为目标值的两个商品（两数之和）、三数之和、四数之和
二分系列(二分答案最大值)9/15.16
2301_78191305的博客
09-16 1017
给你一批机器，及其它制作一块合金所需要的不同种类金属的个数。第一台机器制作一块合金，需要一块A金属、一块B金属、一块C金属。我们对每一类机器所需要的各种种类的金属进行判断，如果仓库里面有，就不需要花钱；如果mid-index<1的，要计算有多少个1。前n项和:(mid-1+1)*(mid-1)/2+leftCount-(mid-1);根据贪心:以index为中心，向两边依次-1，直到减到1为止。如果mid-rightCount<1,先计算多少个1，xxx。
麻将算法详解与控制台实现
麻将游戏算法深入解析及实现代码是一篇关于麻将游戏编程技术的文章，作者分享了他在2006年编写的一种麻将算法，旨在提供一个基础框架用于理解麻将游戏的核心逻辑和编程实现。文章以控制台应用程序的形式展示，尽管...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值