[C++] 麻将胡牌算法

最新推荐文章于 2021-02-13 02:44:27 发布
最新推荐文章于 2021-02-13 02:44:27 发布
阅读量473 收藏 5
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/Ran-Chen/p/9385460.html
版权

麻将的玩法规则众多，核心的玩法是一致的，本文将根据联发科2017年编程挑战赛的复赛题规则来实现。

牌的表示方式
ABCDEFGHI代表一到九萬，abcdefghi代表一到九条，123456789代表一到九饼

三种胡牌牌型

  • 普通牌型，14张牌，形如：3+3+3+3+2。其中数字2代表两张相同的牌可成一组，形如XX。数字3代表三张相同或者连续的牌可成一组，形如XXX、XYZ。
  • 龙七对，14张形如：2+2+2+2+2+2+2。
  • 带杠，即普通牌型里三张一样的牌XXX可以升级成XXXX，称为一道杠。每多一道杠，牌总数可以增加一张。最多可以有4道杠，因此带杠的胡牌，牌总数最多可以达18张。

样例

  • ABCeee345456DD 胡牌，组牌方式为 ABC+eee+345+456+DD，普通牌型。
  • ABeeee345456DD 炸胡，因为AB两张牌未能形成组牌。
  • AAAABC123456333 炸胡，虽然看似组牌OK（AAA+ABC+124+345+456+333）但是不符合任何一种胡牌牌型。
  • AADDFF1133aagg 胡牌，暗七对。
  • AAAABBBBCCCCDDDD88 胡牌，3+3+3+3+2牌型，升级了4道杠。
  • AAA123789 炸胡，不符合任何一种牌型。
  • AAA111345666DEF88 炸胡，不符合任何一种牌型。

算法实现思路

1、普通牌型为3n+2的形式，和龙7对均为14张牌，若有杠则最多有18张牌，因此第一步可以判定，如果牌数小于14或者大于18，则必定不能胡牌；

2、对牌进行从小到大排序，方便后续判断。如果手牌数是14张，可以先判定是否是龙7对(对对胡)，其特点是每张奇数位的牌都和它后一位的牌相等。如果不是对对胡，则进入步骤3；

3、3n+2形式的普通牌型里面有一个对子，因此判断是不是胡牌牌型，可以先找出其中的一个对子。一张牌可能有2张也可能有4张，可以组成对子也可能组成暗杠或者杠，又或者是和后面的牌组成顺子。不管情况有多少种，对子一定是出现在重复的牌之中，只要每次遍历去除一个对子即可。接下来进入步骤4；

4、去除一个对子后，判定是否是3n牌型，即是否是全部由顺子或者暗杠组成。由于牌已经经过排序，所以只要观察第一张牌即可。

  • 如果第一张牌的数量只有一张或者两张，则这张牌必须和后面的牌组成顺子，否则不能胡牌。如果存在这样的顺子，去除这个顺子
  • 如果第一张牌的数量有三张或者四张，则可能组成一个暗杠，或者是和后面的牌组成顺子（先不考虑有杠的情况），去除这个暗杠（顺子）

一直循环以上的判断，满足条件则去掉这三张牌，直到牌数为0时，返回“胡牌”，否则回到步骤3中，将之前去除的对子放回，继续删除下一个对子。如果步骤3中尝试过所有的对子还没能满足胡牌条件时，则返回“不胡牌”；

5、如果牌数为15张，则至少包含一个4张牌的杠，否则不胡牌。如果包含多个杠，则依次遍历删除一个杠，再进入步骤3，判断是不是3n牌型。如果遍历完所有的杠后还不能胡牌，则返回“不胡牌”；

6、如果牌数是16张，则至少包含2个杠，依次遍历删一对杠的组合，余下同步骤5类似。同理，牌数为17张和18张时方法类似。

C++源代码

#include <iostream>
#include <vector>
#include <algorithm>

using std::vector;
using std::cout;

template <typename T>
void showVector(vector <T> & lst);
vector <int> findReptPos(vector <char> & lst);
bool isDDH(const vector <char> & lst);
bool isHU3N(vector <char> & lst);
vector <char> delDUI(const vector <char> & lst, const int x);
bool is3N(vector <char> lst);
int numOfFirst(vector <char> lst);
bool checkGroup(vector <char> lst, const int num);
void delGroup(vector <char> & lst, const int num);
vector <char> delGANG(const vector <char> & lst, const int x);
vector <int> findGangPos(const vector <char> & lst);


int main(int argc, char **argv)
{

    char *mahjong = argv[1];
    vector <char> lst;
    
    for (int i = 0; mahjong[i] != '\0'; ++i)
    {
        lst.push_back(mahjong[i]);
    }

    std::sort(lst.begin(), lst.end());  // 从小到大排序
    
    /*cout << "sort: ";
    showVector(lst);*/

    int num = lst.size();  // 麻将牌数量
    
    if ((num < 14) || (num > 18))
    {
        cout << "BAD";
        return 0;
    }

    if (num == 14)  // 14张牌，2种胡牌法
    {
        if (isDDH(lst))  // 如果是对对胡
        {
            cout << "GOOD";
            return 0;
        }
        if (isHU3N(lst))
        {
            cout << "GOOD";
        }
        else
        {
            cout << "BAD";
        }

        return 0;
         
    }

    if (num == 15)
    {
        vector <int> pos = findGangPos(lst);  // 查找杠的位置     

        if (pos.size() < 1)
        {
            cout << "BAD";
        }
        else
        { 
            // 依次删除一个杠，再判断是否是3N牌型
            for (int i = 0; i < pos.size(); ++i)
            {
                vector <char> newLst = delGANG(lst, pos[i]);
                /*cout << "delGANG/";
                showVector(newLst);*/

                if (isHU3N(newLst))
                {
                    cout << "GOOD";
                    return 0;
                }
                
            }

            cout << "BAD";
        }
    }
    if (num == 16)
    {
        vector <int> pos = findGangPos(lst);  // 查找杠的位置     

        if (pos.size() < 2)  // 少于2个杠肯定不胡牌
        {
            cout << "BAD";
        }
        else
        {
            // 依次删除不同的2个杠组合,再判断是否是3N牌型
            for (int i = 0; i < pos.size() - 1; ++i)
            {
                for (int j = i + 1; j < pos.size(); ++j)
                {
                    // 注意先删除后一个杠，否则位置会变动
                    vector <char> newLst1 = delGANG(lst, pos[j]);
                    vector <char> newLst2 = delGANG(newLst1, pos[i]);

                    /*cout << "delGANG/";
                    showVector(newLst2);*/

                    if (isHU3N(newLst2))
                    {
                        cout << "GOOD";
                        return 0;
                    }
                }
            }

            cout << "BAD";
        }
    }
    if (num == 17)
    {
        vector <int> pos = findGangPos(lst);  // 查找杠的位置     

        if (pos.size() < 3)  // 少于3个杠肯定不胡牌
        {
            cout << "BAD";
        }
        else
        {
            // 依次删除不同的3个杠组合,再判断是否是3N牌型
            for (int i = 0; i < pos.size() - 2; ++i)
            {
                for (int j = i + 1; j < pos.size() - 1; ++j)
                {
                    for (int k = j + 1; k < pos.size(); ++k)
                    {
                        // 注意先删除后一个杠，否则位置会变动
                        vector <char> newLst1 = delGANG(lst, pos[k]);
                        vector <char> newLst2 = delGANG(newLst1, pos[j]);
                        vector <char> newLst3 = delGANG(newLst2, pos[i]);

                        /*cout << "delGANG/";
                        showVector(newLst3);*/

                        if (isHU3N(newLst3))
                        {
                            cout << "GOOD";
                            return 0;
                        }
                    }
                }
            }

            cout << "BAD";
        }
    }
    if (num == 18)
    {
        vector <int> pos = findGangPos(lst);  // 查找杠的位置     

        if (pos.size() != 4)  // 不是4个杠肯定不胡牌
        {
            cout << "BAD";
        }
        else
        {
            // 直接删除4个杠
            vector <char> newLst1 = delGANG(lst, pos[3]);
            vector <char> newLst2 = delGANG(newLst1, pos[2]);
            vector <char> newLst3 = delGANG(newLst2, pos[1]);
            vector <char> newLst4 = delGANG(newLst3, pos[0]);

            /*cout << "delGANG/";
            showVector(newLst4);*/

            if (newLst4[0] == newLst4[1])
            {
                cout << "GOOD";
            }
            else
            {
                cout << "BAD";
            }
        }
    }


    return 0;
}


// 显示列表内容
template <typename T>
void showVector(vector <T> & lst)
{
    vector <T>::iterator iter;  // 迭代器
    for (iter = lst.begin(); iter != lst.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << "\n";
}


// 查找重复牌的位置
vector <int> findReptPos(vector <char> & lst)
{
    vector <int> pos;  // 储存重复牌的位置
    int temp_pos = 0;

    if (lst.size() <= 1)  // 牌数小于等于1，直接返回
    {
        return pos;
    }

    // lst.size() >= 2
    vector <char>::iterator iter2;
    iter2 = lst.begin();
    ++iter2;  // 迭代器不支持算数运算,只能++/--/advance链式操作
    if (lst.front() == *iter2)
    {
        pos.push_back(temp_pos);
    }

    vector <char>::iterator it_front;
    vector <char>::iterator it_back;

    for (auto iter1 = iter2; iter1 != (--lst.end()); iter1++)  // 从第二位到倒数第二位
    {
        ++temp_pos;  // 位置更新

        it_front = iter1; --it_front;
        it_back = iter1; ++it_back;

        // 不等于前面的且等于后面的
        if ((*iter1 != *it_front) && (*iter1 == *it_back))
        {
            pos.push_back(temp_pos);
        }
    }
    

    return pos;
}




// 是否是对对胡
bool isDDH(const vector <char> & lst)
{
    vector <char> newLst = lst;

    for (int i = 0; i <= 12; ++i)
    {
        if (newLst[i] != newLst[i + 1])
        {
            return false;
        }
        ++i;
    }

    return true;
}


// 是否是普通牌型3n
bool isHU3N(vector <char> & lst)
{

    vector <int> pos = findReptPos(lst);  // 找重复牌的位置
    for (int i = 0; i < pos.size(); ++i)  // 依次去掉重复的对子
    {
        vector <char> newLst = delDUI(lst, pos[i]);  // 删除一对牌

        /*cout << "delDUI/";
        showVector(newLst);*/

        if (is3N(newLst))
        {
            return true;
        }
    }
    return false;
}

// 是否是N个顺子或者暗杠
bool is3N(vector <char> lst)
{
    
    if (lst.size() % 3 != 0)
    {
        return false;
    }

    while (lst.size() > 0)
    {
        

        if (lst.size() >= 3)
        {
            int num = numOfFirst(lst);  // 计算第一张牌的重复数量
            
            if (checkGroup(lst, num))  // 检查是否有第一个顺子或者暗杠
            {
                
                delGroup(lst, num);  // 删除这组顺子或者暗杠
                
            }
            else
            {
                return false;
            }

        }
        
        /*cout << "//";
        showVector(lst);*/
    }

    return true;
}


// 检查是否有第一个顺子或者暗杠
bool checkGroup(vector <char> lst, const int num)
{
    if ((num == 1) && (lst[1] == lst[0] + 1))
    {
        // 第二个数可能有重复情况
        for (int i = 2; i < lst.size(); ++i)
        {
            if (lst[i] != lst[1])
            {
                if (lst[i] == lst[0] + 2)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        
    }
    if ((num == 2) && (lst[2] == lst[1] + 1))
    {
        // 第三个数可能有重复情况
        for (int i = 3; i < lst.size(); ++i)
        {
            if (lst[i] != lst[2])
            {
                if (lst[i] == lst[1] + 2)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

    }
    if (num >= 3)
    {
        return true;
    }

    return false;
}

// 删除这组顺子或者暗杠
void delGroup(vector <char> & lst, const int num)
{
    
    if (num == 1)
    {
        vector <char>::iterator iter = ++lst.begin();
        for (int i = 2; i < lst.size(); ++i)
        {
            ++iter;
            if (lst[i] == (1 + lst[1]))
            {
                lst.erase(iter);
                lst.erase(lst.begin());
                lst.erase(lst.begin());
                break;
            }
            
        }
    }

    if (num == 2)
    {
        vector <char>::iterator iter = ++(++lst.begin());
        for (int i = 3; i < lst.size(); ++i)
        {
            ++iter;
            if (lst[i] == (1 + lst[2]))
            {
                lst.erase(iter);
                lst.erase(++lst.begin());  // 删除第二位的牌
                lst.erase(++lst.begin());
                break;
            }
        }
    }

    if (num >= 3)
    {
        lst.erase(lst.begin());
        lst.erase(lst.begin());
        lst.erase(lst.begin());
    }
}




// 计算第一张牌的重复数量
int numOfFirst(vector <char> lst)
{
    if (lst[0] != lst[1])
    {
        return 1;
    }
    if ((lst[0] == lst[1]) && (lst[1] != lst[2]))
    {
        return 2;
    }

    if (lst[0] == lst[2])
    {
        if (lst.size() == 3)
        {
            return 3;
        }
        if ((lst.size() >= 4) && (lst[2] != lst[3]))  // lst[3]一定保证size>=4
        {
            return 3;
        }
            
    }
    if ((lst[0] == lst[3]) && (lst.size() >= 4))
    {
        return 4;
    }
    return 0;
}




// 删除x和x+1位置的一对牌
vector <char> delDUI(const vector <char> & lst, const int x)
{
    vector <char> newLst;

    for (int i = 0; i < lst.size(); ++i)
    {
        if ((i != x) && (i != (x + 1)))
        {
            newLst.push_back(lst[i]);
        }
    }


    return newLst;
}


// 删除起始位置为x的杠（4张牌）
vector <char> delGANG(const vector <char> & lst, const int x)
{
    vector <char> newLst;

    for (int i = 0; i < lst.size(); ++i)
    {
        if ((i < x) || (i > x + 3))
        {
            newLst.push_back(lst[i]);
        }
    }

    return newLst;
}


// 查找杠的位置
vector <int> findGangPos(const vector <char> & lst)
{
    vector <int> pos;
    int temp_pos = 0;

    if (lst.size() < 4)
    {
        return pos;
    }

    for (int i = 0; i < lst.size() - 3; ++i)
    {
        
        if (lst[i] == lst[i + 3])
        {
            pos.push_back(temp_pos);
        }

        ++temp_pos;  // 位置更新
    }

    return pos;
}

程序运行结果

程序从命令行参数取得输入数据，数据为一个字符串，代表一副牌。若这副牌达到胡牌条件，输出GOOD，否则输出BAD。
1397676-20180729152721660-1073506704.png

转载于:https://www.cnblogs.com/Ran-Chen/p/9385460.html

weixin_34236869
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
通用麻将胡牌算法
weixin_30919571的博客
03-30 300
　　声明: 算法并非原创 , 但是来源已经忘记了 , 当时考虑算法的时候看了比较多的麻将胡牌算法 , 想寻找自己比较容易理解的 , 找了几篇,所以算法的出处已然忘记,不过还是感谢下原创吧 . 　　算法理解之后就不难了 , 下面开始详细的阐述了. 1. 将麻将抽象为数字 　　数字 {01 ~ 09} 表示 {1 ~ 9}筒 　　数字 {11 ~ 19} 表示 {1 ~ 9} 条 　...
c++麻将胡牌算法，癞子胡牌算法
04-02
麻将，癞子 胡牌 算法，基于c++代码实现，回溯算法
C++麻将游戏算法深入解析
行者无疆 Happy Programming!
11-20 8706
C++麻将游戏算法深入解析           这两天为了工具箱的完善，整理了这些年引擎开发的一些资料，无意中发现06年写的一个麻将算法，编译运行了一下，还是有点意思的，拿出来整理一下分享给大家。          麻将是一种大家最喜爱的娱乐活动之一，相信所有人都有接触过。我写的这版算法，是可以吃，碰，杠，还有把牌摸完没有人胡时的皇庄和包听。是用控制台方式来表现的，什
C++麻将胡牌算法
08-29
时间复杂弃为 O(n) 可谓原地工作的 C++ 麻将胡牌 算法
麻将胡牌算法(源代码)
08-23
自己做的一个简单的C源代码麻将胡牌算法 分享给大家学习.
麻将胡牌算法
02-03
各种语言的麻将胡牌算法。干货。 c++ c# lua go js麻将胡牌算法
各种语言的麻将胡牌算法。干货。 c++ c# lua go js麻将胡牌算法.zip
08-18
本压缩包中包含了多种编程语言实现的麻将胡牌算法，包括C++、C#、Lua、Go以及JavaScript。虽然标签中提到了“Java”，但在这个上下文中，我们主要关注的是其他五种编程语言的实现。 麻将胡牌算法的核心是判断一副...
基于WIN32控制台交互的广东麻将小游戏，c语言开发，使用了一些c++的类库 设计了洗牌，碰，杠，胡牌算法等
最新发布
03-14
设计了洗牌，碰，杠，胡牌算法。单机，1个真实玩家，3个电脑玩家 基于WIN32控制台交互的广东麻将小游戏，c语言开发，使用了一些c++的类库。设计了洗牌，碰，杠，胡牌算法。单机，1个真实玩家，3个电脑玩家 基于WIN32...
C++实现麻将基本听牌胡牌的算法
热门推荐
sdghchj的博客
08-03 1万+
c++实现麻将的基本胡牌与听牌算法，包括小七对和十三幺牌型。
麻将胡牌算法的判定函数
04-26
非常精辟的胡牌判定方法，同一牌型如果能拆成多种胡牌方式，取番值大的，比如22333444555999，会拆成22,333,444,555,999，而不是234,234,345,55,999
麻将游戏下载 C++
03-20
C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏C++ 麻将游戏
||C++麻将游戏||
06-20
比赛C++写的麻将，实现了基本的功能， 一些在三元小三元什么的没有。
麻将游戏，mfc框架，c++
06-06
麻将游戏麻将小游戏麻将专题介绍:打麻将古已有之,但以前叫打马吊,“三缺一”这三个字更是老少皆知,可见麻将的风靡程度。各个地区也因时代的变迁衍生了各自的麻将玩法,可小游戏即可免费在线玩麻将单机版小游戏,想知道麻麻将连连看 趣味麻将消除 新麻将连连看 黑白麻将 糖果麻将
Dos下C++麻将游戏
weixin_34414196的博客
12-27 158
#include "class_head.h" void set_pai(); //初始化赋值函数 void print_screen(); //初始化屏幕语句函数 char std_input_handle(); void rand_pai(); //随机分配函数 void jiemian(); //菜单 extern player,p_win,pp; void mai...
麻将胡牌算法（C++版）
qq_41810721的博客
12-11 3347
麻将胡牌算法1、麻将的基本规则2、胡牌算法解析牌堆转换 1、麻将的基本规则 常见的麻将一共有三种花色，条、筒、万。每种花色的牌都有1~9个数值，每种数值的牌有4张，总共有493=108张牌。胡牌时手牌必须满足（不包含特殊牌型，如对对胡，大对子等）3ABC+3DDD+EE，即一对将牌除开，剩余的牌全能组成顺子（ABC）或者刻子(DDD)。 2、胡牌算法解析 注：以下分析不包含特殊牌型，如对对胡，大对...
麻将判断胡牌 java_麻将基本胡的算法——Java
weixin_39673947的博客
02-13 1182
算法思想胡的条件必须有一对将(两个相同的牌)除了将，其余牌必须为顺子或刻子算法(精简版)提取所有将牌去除所有刻子去除所有顺子没有牌了，胡；还有牌，不胡算法(完整版)提取所有将牌(如果要胡，将牌是必须存在的，而且将牌可能会有多种)取一对将牌，如果没有将牌了，则表示不能胡将手牌去除选取的将牌将剩余的手牌去除所有的刻子，去除所有的刻子后如果手牌没有了，则胡；手牌还有，则继续第5步判断将手牌去除所有的顺子...
Unity3D 通用麻将胡牌算法
TxNet
04-08 6912
声明: 算法并非原创 , 但是来源已经忘记了 , 当时考虑算法的时候看了比较多的麻将胡牌算法 , 想寻找自己比较容易理解的 , 找了几篇,所以算法的出处已然忘记,不过还是感谢下原创吧 .  　　算法理解之后就不难了 , 下面开始详细的阐述了. 1. 将麻将抽象为数字 　　数字 {01 ~ 09} 表示  {1 ~ 9} 筒 　　数字 {11 ~ 19} 表示  {1 ~ 9
c++ 贵阳麻将 胡牌算法
06-07
在贵阳麻将游戏中，判断胡牌需要遵循以下规则： 1. 手牌中有七对牌，即七对同样的牌，可以胡牌。 2. 手牌中有四副牌，即三张相同的牌加一张相同序数的牌，可以胡牌。 3. 手牌中有将牌，即两张相同的牌，如果能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值