斗地主出牌算法

最新推荐文章于 2023-02-08 18:09:50 发布
最新推荐文章于 2023-02-08 18:09:50 发布
阅读量1.5k 收藏 5
点赞数 1
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shaogeiwojijiwaiwai/article/details/83872914
版权
根据斗地主出牌规则.对玩家出的牌进行检验.判断是否符合出牌规则.

(关于斗地主的出牌规则网上有很多)

思路:将玩家的牌按升序排序.然后将牌进行拆分,分存在4个数组中.拆分规则如下:

假设有牌:333\444\555\789

则拆分后数组中的数据如下

arr[0]:345789

arr[1]:345

arr[2]:345

arr[3]:null

可以看出拆分规则是:如果遇到相同数字的牌则存到下一个数组的末尾.

拆分完后可以根据各数组的存储情况判定玩家出牌的类型,上面例子arr[3]为空.可以排除掉4带1(2).炸.的情况根据arr[2]为顺子且个数大于1,且arr[2]中存放的牌的张数乘以3刚好等于arr[0]的张数+arr[1]的张数.则可以判定是三带一的飞机.其他类型的牌也有相似的规律.以下是该算法的核心源代码.本算法用C#编写. 

using System;
using System.Collections.Generic;
using System.Text;

namespace LordLibrary
{

     /*

      *以下程序版权由林奕霖所有,有兴趣的朋友可以用来交流和探讨.但请别用于商业用途.否则后果自负.

      *您可以自由拷贝修改此源代码,但必须保留此注释.

      */

    public class CheckType
    {

        private static int[][] DiffRow(int[] nums)
        {
            int[][] list = new int[4][];
            for (int i = 0; i < list.Length; i++)
            {
                list[i] = new int[20];
            }
            int[] rowIndex = new int[4];
            int columIndex = 0;

            for (int i = 0; i < nums.Length; i++)
            {
                if (i + 1 < nums.Length)
                {
                    if (nums[i] != 0)
                    {
                        list[columIndex][rowIndex[columIndex]] = nums[i];
                        rowIndex[columIndex]++;
                    }

                    if (nums[i] == nums[i + 1])
                    {
                        columIndex++;
                    }
                    else
                    {
                        columIndex = 0;
                    }
                }
                else if (nums[i] != 0)
                    list[columIndex][rowIndex[columIndex]] = nums[i];
            }
            return list;
        }


        private static int checkListCount(int[][] list, int rowIndex, int compStart, int rowMaxCount)
        {

/* LIST 代表单顺.

*DOUB 代表双顺.

*FEI0 代表三顺.

*FEI1 代表三带一的飞机

*FEI2 代表三带二的飞机

*FOR1 代表四带1

*FOR2 代表四带2

*ROCK 代表大小王

*/
            int listCount = 1;
            for (int i = compStart; i < rowMaxCount - 1; i++)
            {
                if (list[rowIndex][i] + 1 == list[rowIndex][i + 1])
                    listCount++;
                else
                    listCount = 1;
            }
            return listCount;
        }
        public static string getCardType(int[] nums)
        {
            int[][] list = DiffRow(nums);
            int[] counts = new int[4];
            for (int k = 0; k < 4; k++)
            { 
              counts[k] = Array.IndexOf(list[k], 0);
            }
            int MaxValue = 0;
            int listCount = 0;
            string type = string.Empty;
            //当第4行牌的数量为1的时候   
            #region
            if (counts[3] == 1)
            {
                int index = Array.IndexOf(list[2], list[3][0]);
                switch (counts[2])
                {
                    case 1:
                        MaxValue = list[3][0];
                        if (counts[0] == 1)
                        {
                            type = "BOMB:4:" + MaxValue;
                        }
                        else if (counts[0] + counts[1] == 4)
                        {
                            type = "FOR1:6:" + MaxValue;
                        }
                        else if (counts[0] == counts[1] && counts[0] == 3)
                        {
                            type = "FOR2:8:" + MaxValue;
                        }

                        break;
                    case 2:
                        if (list[2][0] + 1 == list[2][1] && counts[1] == counts[2] && counts[0] == 3)
                        {
                            MaxValue = list[2][counts[2] - 1];
                            type = "FEI1:" + counts[2] + ":" + MaxValue;
                        } break;
                    case 3:
                        if (checkListCount(list, 2, 0, counts[2]) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                        {
                            MaxValue = list[2][counts[2] - 1];
                            type = "FEI1:" + counts[2] + ":" + MaxValue;
                        }
                        else if (Array.IndexOf(list[2], list[3][0]) == 0 && counts[0] == counts[2])
                        {
                            if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1)
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI2:" + listCount + ":" + MaxValue;
                            }

                        }
                        else if (Array.IndexOf(list[2], list[3][0]) == counts[2] - 1 && counts[0] == counts[2])
                        {
                            if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1)
                            {
                                MaxValue = list[2][counts[2] - 2];
                                type = "FEI2:" + listCount + ":" + MaxValue;
                            }
                        }
                        break;
                    case 4:
                        if (index == 0 && counts[0] == counts[1] && counts[0] == 5)
                        {
                            if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1)
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI2:" + listCount + ":" + MaxValue;
                            }
                        }
                        else if (index == counts[2] - 1 && counts[0] == counts[1] && counts[0] == 5)
                        {
                            if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1)
                            {
                                MaxValue = list[2][counts[2] - 2];
                                type = "FEI2:" + listCount + ":" + MaxValue;
                            }
                        }
                        else if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                        {
                            MaxValue = list[2][counts[2] - 1];
                            type = "FEI1:" + listCount + ":" + MaxValue;
                        }
                        break;
                    case 5:
                        if (index == 0)
                        {
                            if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI1:" + listCount + ":" + MaxValue;
                            }
                            else if (listCount == counts[2] - 1 && counts[0] == counts[1])
                            {
                                if (counts[0] + 1 == 2 * (counts[2] - 1))
                                {
                                    MaxValue = list[2][counts[2] - 1];
                                    type = "FEI2:" + listCount + ":" + MaxValue;
                                }
                                else if (2 * (counts[0] + 1) == 3 * (counts[2] - 1))
                                {
                                    MaxValue = list[2][counts[2] - 1];
                                    type = "FEI1:" + listCount + ":" + MaxValue;
                                }
                            }
                        }
                        else if (index == counts[2] - 1)
                        {
                            if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI1:" + listCount + ":" + MaxValue;
                            }
                            else if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && counts[0] == counts[1])
                            {
                                if (counts[0] + 1 == 2 * (counts[2] - 1))
                                {
                                    MaxValue = list[2][counts[2] - 2];
                                    type = "FEI2:" + listCount + ":" + MaxValue;
                                }
                                else if (2 * (counts[0] + 1) == 3 * (counts[2] - 1))
                                {
                                    MaxValue = list[2][counts[2] - 2];
                                    type = "FEI1:" + listCount + ":" + MaxValue;
                                }
                            }
                        }
                        else
                        {
                            if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI1:" + listCount + ":" + MaxValue;
                            }
                        }
                        break;
                    case 6:
                        if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                        {
                            MaxValue = list[2][counts[2] - 1];
                            type = "FEI1:" + listCount + ":" + MaxValue;
                        }
                        else if (index == 0 && listCount == counts[2] - 1 && counts[0] + counts[1] + 2 == 3 * (counts[2] - 1))
                        {
                            MaxValue = list[2][counts[2] - 1];
                            type = "FEI1:" + listCount + ":" + MaxValue;
                        }
                        else if (index == counts[2] - 1 && (listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && counts[0] + counts[1] + 2 == 3 * (counts[2] - 1))
                        {
                            MaxValue = list[2][counts[2] - 2];
                            type = "FEI1:" + listCount + ":" + MaxValue;
                        }
                        break;
                }
            }
            #endregion
            //当第4行牌的数量为2的时候
            #region
            if (counts[3] == 2)
            {
                switch (counts[2])
                {

                    default:
                        if (counts[2] >= 2 && counts[2] < 6)
                        {
                            if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI1:" + listCount + ":" + MaxValue;
                            }
                        }
                        break;
                    case 6:
                        int firstIndex = Array.IndexOf(list[2], list[3][0]);
                        int secIndex = Array.IndexOf(list[2], list[3][1]);

                        if (secIndex == 1)
                        {
                            if ((listCount = checkListCount(list, 2, 2, counts[2])) == counts[2] - 2 && counts[0] == counts[1] && counts[0] + 2 == 2 * (counts[2] - 2))
                            {
                                MaxValue = list[2][counts[2] - 1];
                                type = "FEI2:" + listCount + ":" + MaxValue;
                            }
                        }
                        else if (secIndex == counts[2] - 1)
                        {
                            if (firstIndex == 0)
                            {
                                if ((listCount = checkListCount(list, 2, 1, counts[2] - 1)) == counts[2] - 2 && counts[0] == counts[1] && counts[0] + 2 == 2 * (counts[2] - 2))
                                {
                                    MaxValue = list[2][counts[2] - 2];
                                    type = "FEI2:" + listCount + ":" + MaxValue;
                                }
                            }
                            else if (firstIndex == secIndex - 1)
                            {
                                if ((listCount = checkListCount(list, 2, 0, counts[2] - 2)) == counts[2] - 2 && counts[0] == counts[1] && counts[0] + 2 == 2 * (counts[2] - 2))
                                {
                                    MaxValue = list[2][counts[2] - 3];
                                    type = "FEI2:" + listCount + ":" + MaxValue;
                                }
                            }
                        }
                        if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1 && 2 * counts[0] + 3 == 3 * (counts[2] - 1))
                        {
                            MaxValue = list[2][counts[2] - 1];
                            type = "FEI1:" + listCount + ":" + MaxValue;
                        }
                        else if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && 2 * counts[0] + 3 == 3 * (counts[2] - 1))
                        {
                            MaxValue = list[2][counts[2] - 2];
                            type = "FEI1:" + listCount + ":" + MaxValue;
                        }


                        break;
                }
            }
            #endregion
            //当第4行牌的数量大于2的时候
            #region
            if (counts[3] > 2)
            {
                if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2] && counts[0] + counts[1] + counts[3] == 3 * counts[2])
                {
                    MaxValue = list[2][counts[2] - 1];
                    type = "FEI1:" + listCount + ":" + MaxValue;
                }
            }
            #endregion
            //当第4行牌的数量为0,第三行牌的数量大于0
            #region
            if (counts[3] == 0 && counts[2] > 0)
            {

                if ((listCount = checkListCount(list, 2, 0, counts[2])) == counts[2])
                {
                    if (counts[0] == counts[2])
                    {
                        MaxValue = list[2][counts[2] - 1];
                        type = "FEI0:" + listCount + ":" + MaxValue;
                    }
                    else if (counts[0] + counts[1] == 3 * counts[2])
                    {

                        MaxValue = list[2][counts[2] - 1];
                        type = "FEI1:" + listCount + ":" + MaxValue;
                    }
                    else if (counts[0] + counts[1] == 4 * counts[2] && counts[0] == counts[1])
                    {
                        MaxValue = list[2][counts[2] - 1];
                        type = "FEI2:" + listCount + ":" + MaxValue;
                    }
                }
                if ((listCount = checkListCount(list, 2, 1, counts[2])) == counts[2] - 1 && counts[0] + counts[1] + 1 == 3 * (counts[2] - 1))
                {
                    MaxValue = list[2][counts[2] - 1];
                    type = "FEI1:" + listCount + ":" + MaxValue;
                }
                else if ((listCount = checkListCount(list, 2, 0, counts[2] - 1)) == counts[2] - 1 && counts[0] + counts[1] + 1 == 3 * (counts[2] - 1))
                {
                    MaxValue = list[2][counts[2] - 2];
                    type = "FEI1:" + listCount + ":" + MaxValue;
                }
            }
            #endregion
            //当第3行牌的数量为0，第二行牌的数量大于0
            #region
            if (counts[2] == 0 && counts[1] > 0)
            {
                if (counts[0] == 1)
                {
                    MaxValue = list[1][counts[1] - 1];
                    listCount = counts[1];
                    type = "DOUB:" + listCount + ":" + MaxValue;
                }
                else
                {
                    if (counts[1] > 2 && counts[0] == counts[1] && (listCount = checkListCount(list, 1, 0, counts[1])) == counts[1])
                    {
                        MaxValue = list[1][counts[1] - 1];
                        type = "DOUB:" + listCount + ":" + MaxValue;
                    }
                }
            }
            #endregion
            //当第2行牌的数量为0
            #region
            if (counts[1] == 0)
            {
                if (counts[0] == 1)
                {
                    MaxValue = list[0][counts[0] - 1];
                    listCount = counts[0];
                    type = "LIST:" + listCount + ":" + MaxValue;
                }
                else if (counts[0] == 2 && list[0][0] == 16 && list[0][1] == 17)
                {
                    type = "ROCK:2:17";
                }
                else if (counts[0] >= 5 && (listCount = checkListCount(list, 0, 0, counts[0])) == counts[0])
                {
                    MaxValue = list[0][counts[0] - 1];
                    listCount = counts[0];
                    type = "LIST:" + listCount + ":" + MaxValue;
                }
            }
            #endregion
            String[] cmd= type.Split(new char[]{':'});
            int big = Array.IndexOf(nums, 16);
            int small = Array.IndexOf(nums, 17);
            if (cmd.Length > 0 && cmd[0]!=string.Empty)
            {
                if ((cmd[0]=="LIST" || cmd[0]=="DOUB" || cmd[0]=="FEI0" || cmd[0]=="FEI1"|| cmd[0]=="FEI2")&& (int.Parse(cmd[1]))>1)
                {
                    type = int.Parse(cmd[2]) > 14 ? string.Empty : type;
                }
                else if (cmd[0] == "FOR1" || cmd[0] == "FOR2")
                {
                    type = (big >0 && small>0) ? string.Empty : type;
                }
            }
            return type;
        }
    }
}

shaogeiwojijiwaiwai
关注
java 斗地主出牌算法_斗地主智能（AI）出牌算法
weixin_32973319的博客
02-13 3520
我以前写过一个斗地主机器人。思路如下，希望对你有帮助。};^}2Xo+斗地主AI设计}Fm\+JOS一、牌型7u|%^Ao61 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。QhsVIta2 炸弹：相同点数的四张牌在一起的牌型，比如四条A。除火箭外，它可以打任何牌型，炸弹对炸弹时，要比大小。-qfnUh3 单支(一手牌)：单张牌，如一支3。xdqK.Z%?4 对子(一手牌)：相...
简单的斗地主出牌算法（python）
最新发布
sikeji5902的博客
04-25 1092
【代码】简单的斗地主出牌算法（python）
斗地主出牌算法(java版)
08-21
本算法采用Java语言编写,是网页FLASH版斗地主客户端的核心程序!
斗地主出牌算法(as版)
08-21
本算法采用ActionScript3.0动态脚本语言编写,是网页FLASH版斗地主客户端的核心程序!
斗地主中的提示出牌算法(Lua)
hyx18775752051的博客
03-27 4108
没有看到别人怎么写的，这个是上家公司老板写的，当时服务器用的js写的，我搬到了客户端上，换成了lua。然后现在工作要用到，一时还想不起来。所以说造过的轮子要记录下来，方便自己，也方便他人。 主要的思路就是根据上家的出牌，先判断出type(单，对，顺子，炸弹等)，然后根据type去寻找该类型的所有牌组合。所以每个类型都要有个对应的方法。可以在找的时候直接传入参数，直接找大于该牌的组合。也可以找出该...
Lua脚本的斗地主的提示出牌算法。
03-27
Lua脚本的斗地主的提示出牌算法。 包括： 查找某牌型的算法：查找所有的单牌，查找所有的对子，查找所有的三条，查找所有的单顺，双顺，飞机，飞机带单，飞机带双。 排序算法。 转成花色，转成点数， 比较算法等。
斗地主 出牌大小判断算法 （无AI出牌功能）
10-05
用遍历的思想实现的算法，只实现了判断出牌是否符合规则，没有实现电脑的AI智能出牌（试过用hash队列实现，但颇有点复杂，写不下去了），再有也没有做全面的测试，希望有兴趣的朋友们如果测出了其中的bug请务必通知本人，先谢过了。第一 次传东西，请大家多支持 :))
java 斗地主出牌算法_斗地主AI算法——第七章の被动出牌(1)
weixin_35361243的博客
03-07 648
哎，之前扯了那么多蛋，终于讲出牌了！本章开始讲被动出牌的逻辑算法。首先我们先把架子搭起来，被动出牌我们肯定是要知道场上目前打出的是什么牌型。在第二章数据结构里我们定义过，游戏全局类里面有一个存放当前牌型结构的成员，即//当前打出牌的类型数据，被动出牌时玩家根据这里做出筛选CardGroupDatauctNowCardGroup;我们即将通过他进行类型的筛选，所以肯定是要枚举各类牌型的，也就是这个...
斗地主AI算法——第七章の被动出牌(1)
九日王朝
04-26 9408
哎，之前扯了那么多蛋，重要讲出牌了！ 本章开始讲被动出牌的逻辑算法。首先我们先把架子搭起来，被动出牌我们肯定是要知道场上目前打出的是什么牌型。 在第二章数据结构里我们定义过，游戏全局类里面有一个存放当前牌型结构的成员，即 //当前打出牌的类型数据，被动出牌时玩家根据这里做出筛选 CardGroupData uctNowCardGroup; 我们即将通过他进行类型的筛选，所以整个
斗地主智能（AI）出牌算法
热门推荐
xdx2ct1314的专栏
01-26 4万+
去年有想写个斗地主的小游戏，自己玩玩。找了很多资料，后来好不容易在网上找到了一个AI算法。转过的的时候是贴在自己电脑的TXT文本上，再次感谢下原作者。现在借花献佛发给你参考下。    我以前写过一个斗地主机器人。思路如下，希望对你有帮助。   斗地主AI设计  一、牌型           1 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。           2 炸弹
斗地主核心算法
03-09
斗地主的核心相关算法，机器人和出牌提示可以在此基础上继续完善
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
斗地主AI 算法
06-04
斗地主机器人模拟打牌 C# 代码 代码能运行，供大家参考
斗地主AI算法——第八章の被动出牌(2)
九日王朝
04-27 7804
上一章我们已经搭好了被动出牌的基本架子，本章我们主要解决面对不同牌型分支的出牌策略问题。 在这里我把出牌逻辑分为四个阶段，也就是策略的优先级。分别是：【直接打光手牌】→【同类型牌压制】→【炸弹王炸压制】→【不出】 第一阶段【直接打光手牌】就是说如果我们可以一次性把手牌打出，那就不用考虑接下来价值之类的问题了，因为已经赢了。这种情况可能是对方打出的牌型和你一样且你比他大，或者你剩的牌是炸
一种初级通用高度提炼的斗地主提示算法
weixin_45043548的博客
02-08 620
一种初级通用高度提炼的斗地主提示算法
unity开发 斗地主算法—提示AI（提示出牌）
csdn_cjt的博客
11-27 8173
牌型的定义在http://blog.csdn.net/csdn_cjt/article/details/78593140 第一章 这是第四章 下面是代码 #region 提示出牌 public static Dictionary> FindPromptCards(List myCards, List lastCards, DDZ_P
斗地主中自主出牌的游戏逻辑
fanhenghui的专栏
12-23 880
判断所有手牌的是否是某个已知类型，如果是的话直接出 找出可能包含顺子的所有牌 如果找出的包含顺子的牌不为空 从上面找出的牌中去掉炸弹 从上面找出的牌中去掉三张 如果去掉顺子和三张之后顺子还存在，则出顺子 查找手牌中的所有炸弹 删除所有炸弹 查找手牌中的所有飞机 删除所有飞机 查找手牌中的所有三张 删除所有三张 查找手牌中的所有连对 删除所有连对 如果有飞机 看看是否...
斗地主AI算法——第一章の业务逻辑
九日王朝
04-26 4万+
转眼间快到了五月，帝都的天气也变的非常梦幻。 时而酷暑炎热，时而狂风席卷。 而不管外面如何，我们也只能在办公室里茕茕无依的撸着代码，无可奈何的负着韶华。 世界是寂寞的，寂寞到不只是寂寞，而是死一般的寂寞。 或许AI就是因此而生吧，因为到了最后，能一直陪伴我们走下去的，或许也就只有程序了。 好吧不装逼了，近期在研究skynet服务器框架，里面有斗地主的demo，于是想
斗地主—游戏规则
ylqmf的专栏
03-12 4987
斗地主—游戏规则 该游戏由三人玩一副牌，地主为一方，其余两家为另一方，双方对战，先出完的一方胜。出牌规则类似"争上游"。 牌型： 1、火箭：即双王（双鬼牌），什么牌型都可打，是最大的牌。 2、炸弹：四张同点牌。如四个5。除火箭和比自己大的炸弹外，什么牌型都可打。 一般牌型： 3、单牌：单个牌。 4、对牌：两个点数相同的牌。 5、三张牌：三张点数相同的牌。 6、三带一：三张同点牌 ＋ 一张单牌。例如
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值