四川麻将胡牌判定（Python、C#、C++）

已于 2022-02-19 15:08:33 修改
阅读量2k 收藏 9
点赞数 2
分类专栏： C++ c# python 文章标签： python c# c++
于 2022-02-18 20:07:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41841073/article/details/123010265
版权
c# 同时被 3 个专栏收录
24 篇文章 0 订阅
订阅专栏
python
17 篇文章 0 订阅
订阅专栏
C++
14 篇文章 0 订阅
订阅专栏

**
一下是三种判定四川麻将（血战到底）胡牌的算法，主要思想是递归+回溯~

Python写法：

**

# -*- coding: utf-8 -*-
# @Time     :2022/2/18 14:15
# @Author   :LuoLin01


class PmaJong(object):
    def __init__(self):
        self.m_TypeNum = []
        self.m_CardNum = []
        self.HasCouple = False
        for i in range(3):
            self.m_TypeNum.append(0)
            self.m_CardNum.append([0]*9)

        self.g_typedef = ['w', 't', 'd']  # 万、条、筒
        self.m_GangNum = 0

    def InitData(self, cards_str):
        if not len(cards_str) or len(cards_str) % 2:  # 必然是偶数才能判断是否完成
            print("数据初始化出错")
            return

        cur_idx = 0
        while cur_idx < len(cards_str):
            cur_c = cards_str[cur_idx]

            nNum = ord(cur_c) - ord('0')
            cType = cards_str[cur_idx + 1]
            for i in range(3):
                if cType == self.g_typedef[i]:
                    self.m_TypeNum[i] += 1
                    self.m_CardNum[i][nNum - 1] += 1
                    break

            cur_idx += 2

    def IsSevenCouple(self):
        if 14 == self.m_TypeNum[0] + self.m_TypeNum[1] + self.m_TypeNum[2]:
            for i in range(3):
                for j in range(9):
                    if self.m_CardNum[i][j] != 0 and self.m_CardNum[i][j] != 2:
                        return False

    def IsWin(self):
        if self.m_TypeNum[0] and self.m_TypeNum[1] and self.m_TypeNum[2]:
            print("不是缺一门\n")
            return False
        if self.IsSevenCouple():
            print("七小对\n")
            return True

        for i in range(3):
            if not self.IsOneTypeWin(self.m_CardNum[i], self.m_TypeNum[i], i):
                print("花色:%s不满足胡牌\n" % self.g_typedef[i])
                return False

        if not self.HasCouple:
            print("没有对子，不能胡牌\n")
            return False

        if self.m_TypeNum[0] + self.m_TypeNum[1] + self.m_TypeNum[2] - 14 != self.m_GangNum:
            print("你丫诈和，牌的数量不对.\n")
            return False

        print("正常胡牌\n")
        return True

    def IsOneTypeWin(self, pCards, Num, type):
        print(pCards)
        if not Num:
            return True
        tmp = ""
        for i in range(9):
            if pCards[i] >= 2 and not self.HasCouple:
                pCards[i] -= 2
                self.HasCouple = True
                if self.IsOneTypeWin(pCards, Num - 2, type):
                    tmp += str(i+1) + self.g_typedef[type] + str(i+1) + self.g_typedef[type]
                    print("当前牌：%s\n", tmp)
                    return True
                pCards[i] += 2
                self.HasCouple = False

            if pCards[i] == 4:
                pCards[i] -= 4
                if self.IsOneTypeWin(pCards, Num - 4, type):
                    self.m_GangNum += 1
                    tmp += (str(i + 1) + self.g_typedef[type]) * 4
                    print("当前牌：%s\n", tmp)
                    return True
                pCards[i] += 4

            if pCards[i] >= 3:
                pCards[i] -= 3
                if self.IsOneTypeWin(pCards, Num - 3, type):
                    tmp += (str(i + 1) + self.g_typedef[type]) * 3
                    print("当前牌：%s\n", tmp)
                    return True
                pCards[i] += 3

            if i < 7 and pCards[i] and pCards[i + 1] and pCards[i + 2]:
                pCards[i] -= 1
                pCards[i + 1] -= 1
                pCards[i + 2] -= 1
                if self.IsOneTypeWin(pCards, Num - 3, type):
                    tmp += str(i + 1) + self.g_typedef[type] + str(i + 2) + self.g_typedef[type] + str(i + 3) + self.g_typedef[type]
                    print("当前牌：%s\n", tmp)
                    return True
                pCards[i] += 1
                pCards[i + 1] += 1
                pCards[i + 2] += 1

        return False


if __name__ == "__main__":
    cur_s = "1w1w1w2d3d4d2w3w4w7d8d9d5w5w"
    mahJong = PmaJong()
    mahJong.InitData(cur_s)
    if mahJong.IsWin():
        print("win !!!!!")
    else:
        print("False !!!!!")

## c#写法

using System;
namespace ConsoleApp1
{
    class CSMahJangg
    {
        public CSMahJangg()
        {

        }
        public int[] m_TypeNum = new int[3];
        public int[][] m_CardNum =
            {
            new int[9],
            new int[9],
            new int[9],
        };
        public int m_GangNum = 0;
        public char[] g_typedef = new char[] { 'w', 't', 'd' };

        public void Init(string pCards)
        {
            int cur_idx = 0;

            char pTmp = pCards[cur_idx];
            int nNum = 0;
            char cType;
            while (cur_idx < pCards.Length)
            {
                pTmp = pCards[cur_idx];
                nNum = pTmp - '0';
                cType = pCards[cur_idx+1];
                for (int i = 0; i < 3; i++)
                {
                    if (cType == g_typedef[i])
                    {
                        m_TypeNum[i]++;
                        m_CardNum[i][nNum - 1]++;
                        break;
                    }
                }
                cur_idx += 2;
            }
        }

        public bool IsSevenCouple()
        {
            if (14 == m_TypeNum[0] + m_TypeNum[1] + m_TypeNum[2])
            {
                for (int i = 0; i < 3; i++)
                {
                    for (int j = 0; j < 9; j++)
                    {
                        if (m_CardNum[i][j] != 0 && m_CardNum[i][j] != 2)
                        {
                            return false;
                        }
                    }
                }
                return true;
            }
            return false;
        }

        public bool IsWin()
        {
            if (m_TypeNum[0] > 0 && m_TypeNum[1] > 0 && m_TypeNum[2] > 0)
            {
                //不是缺一门
                Console.WriteLine("不是缺一门\n");
                return false;
            }
            if (IsSevenCouple())
            {
                //七小对
                Console.WriteLine("七小对\n");
                return true;
            }
            //正常胡牌：有一个对子，其余的要么三支顺子，要么三支一样的（或四只）
            bool HasCouple = false;
            for (int i = 0; i < 3; i++)
            {
                if (!IsOneTypeWin(m_CardNum[i], m_TypeNum[i], ref HasCouple, i))
                {
                    Console.WriteLine("花色:{0}不满足胡牌\n", g_typedef[i]);
                    return false;
                }
            }
            if (!HasCouple)
            {
                Console.WriteLine("没有对子，不能胡牌\n");
                return false;
            }
            if (m_TypeNum[0] + m_TypeNum[1] + m_TypeNum[2] - 14 != m_GangNum)
            {
                Console.WriteLine("你丫诈和，牌的数量不对.\n");
                return false;
            }
            Console.WriteLine("正常胡牌\n");
            return true;
        }

        public bool IsOneTypeWin(int [] pCards, int Num, ref bool HasCouple, int type) // 递归回溯求解
        {
            if (Num == 0)
            {
                return true;
            }
            string tmp = "";
            for (int i = 0; i < 9; i++)
            {
                if (pCards[i] >= 2 && !HasCouple)
                {
                    pCards[i] -= 2;
                    HasCouple = true;
                    if (IsOneTypeWin(pCards, Num - 2, ref HasCouple, type))
                    {
                        tmp += Convert.ToString(i + 1) + g_typedef[type] + Convert.ToString(i + 1) + g_typedef[type];
                        Console.WriteLine("当前牌：{0}\n", tmp);
                        return true;
                    }
                    pCards[i] += 2;
                    HasCouple = false;
                }
                if (pCards[i] == 4) // 有四个一样的
                {
                    pCards[i] -= 4;
                    if (IsOneTypeWin(pCards, Num - 4, ref HasCouple, type))
                    {
                        tmp += Convert.ToString(i + 1) + g_typedef[type] + Convert.ToString(i + 1) + g_typedef[type] +
                            Convert.ToString(i + 1) + g_typedef[type] + Convert.ToString(i + 1) + g_typedef[type];
                        Console.WriteLine("当前牌：{0}\n", tmp);
                        m_GangNum++;
                        return true;
                    }
                    pCards[i] += 4;
                }
                if (pCards[i] >= 3)
                {
                    pCards[i] -= 3;
                    if (IsOneTypeWin(pCards, Num - 3, ref HasCouple, type))
                    {
                        tmp += Convert.ToString(i + 1) + g_typedef[type] + Convert.ToString(i + 1) + g_typedef[type] +
                            Convert.ToString(i + 1) + g_typedef[type] ;
                        Console.WriteLine("当前牌：{0}\n", tmp);
                        return true;
                    }
                    pCards[i] += 3;
                }
                if (i < 7 && pCards[i]>0 && pCards[i + 1]>0 && pCards[i + 2]>0) // 顺子
                {
                    pCards[i] -= 1;
                    pCards[i + 1] -= 1;
                    pCards[i + 2] -= 1;
                    if (IsOneTypeWin(pCards, Num - 3, ref HasCouple, type))
                    {
                        tmp += Convert.ToString(i + 1) + g_typedef[type] + Convert.ToString(i + 2) + g_typedef[type] +
                            Convert.ToString(i + 1) + g_typedef[type] + Convert.ToString(i + 3) + g_typedef[type];
                        Console.WriteLine("当前牌：{0}\n", "123");
                        return true;
                    }
                    pCards[i] += 1;
                    pCards[i + 1] += 1;
                    pCards[i + 2] += 1;
                }
            }
            return false;
        }



    }

    class Program
    {
        static void Main(string[] args)
        {
            CSMahJangg mj = new CSMahJangg();
            string s = "2d1w1w1w2d3d4d2w3w4w7d8d9d5w5w";
            mj.Init(s);
            Console.WriteLine("当前牌：{0}\n", "123");
            if (mj.IsWin())
            {
                Console.WriteLine("Win!!!!!");
            }
            else
            {
                Console.WriteLine("False!!!!!");
            }



            Console.ReadKey();

        }
    }
}

**

c++写法

**

#include <stdio.h>
#include <cstring>
#include<iostream>
#include <vector>
#define TEST 0
#if TEST
#define LOG(fmt, ...) printf("line=%d file=%s" fmt"\n",  __LINE__, __FILE__, ##__VA_ARGS__)
#else
#define LOG(fmt, ...) printf( fmt"\n", ##__VA_ARGS__)
#endif
using std::vector;

const char g_typedef[3] = { 'w', 't', 'd' };//万、条、筒


class CMahJangg
{
public:
	CMahJangg()
	{
		m_TypeNum = vector<int>(3, 0);
		m_CardNum = vector<vector<int>>(3, vector<int>(9));
		for (int i = 0; i < 3; i++)
		{
			m_TypeNum[i] = 0;
			memset(log, 0, sizeof(char) * 100);
			m_GangNum = 0;  
		}

	}
	void Init(char *pCards)
	{
		char *pTmp = pCards;
		int nNum = 0;
		char cType = 0;
		while (*pTmp != '\0')
		{
			nNum = *pTmp - '0';
			cType = *(pTmp + 1);
			for (int i = 0; i < 3; i++)
			{
				if (cType == g_typedef[i])
				{
					m_TypeNum[i]++;
					m_CardNum[i][nNum - 1]++;
					break;
				}
			}
			pTmp += 2;
		}
	}
	bool IsSevenCouple()
	{
		if (14 == m_TypeNum[0] + m_TypeNum[1] + m_TypeNum[2])
		{
			for (int i = 0; i < 3; i++)
			{
				for (int j = 0; j < 9; j++)
				{
					if (m_CardNum[i][j] != 0 && m_CardNum[i][j] != 2)
					{
						return false;
					}
				}
			}
			return true;
		}
		return false;
	}
	bool IsWin()
	{
		if (m_TypeNum[0] && m_TypeNum[1] && m_TypeNum[2])
		{
			//不是缺一门
			LOG("不是缺一门\n");
			return false;
		}
		if (IsSevenCouple())
		{
			//七小对
			LOG("七小对\n");
			return true;
		}
		//正常胡牌：有一个对子，其余的要么三支顺子，要么三支一样的（或四只）
		bool HasCouple = false;
		for (int i = 0; i < 3; i++)
		{
			if (!IsOneTypeWin(m_CardNum[i], m_TypeNum[i], HasCouple, i))
			{
				LOG("花色:%c不满足胡牌\n", g_typedef[i]);
				return false;
			}
		}
		if (!HasCouple)
		{
			LOG("没有对子，不能胡牌\n");
			return false;
		}
		if (m_TypeNum[0] + m_TypeNum[1] + m_TypeNum[2] - 14 != m_GangNum)
		{
			LOG("你丫诈和，牌的数量不对.\n");
			return false;
		}
		LOG("正常胡牌\n");
		return true;
	}
	void Print(vector<int> pCards, int type)
	{
		char t = g_typedef[type];
		for (int i=0; i<9; i++ )
		{
			for (int j = 0; j < pCards[i]; j++)
			{
				std::cout << i+1 << "" << t << " ";
			}
			
		}
		std::cout << std::endl;
	}
	bool IsOneTypeWin(vector<int> pCards, int Num, bool &HasCouple, int type) // 递归回溯求解
	{
		Print(pCards, type);
		if (Num == 0)
		{
			return true;
		}
		char tmp[20] = { 0 };
		for (int i = 0; i < 9; i++)
		{
			if (pCards[i] >= 2 && !HasCouple)
			{
				pCards[i] -= 2;
				HasCouple = true;
				if (IsOneTypeWin(pCards, Num - 2, HasCouple, type))
				{
					sprintf(tmp, "%d%c%d%c ", i + 1, g_typedef[type], i + 1, g_typedef[type]);
					strcat(log, tmp);
					LOG("当前牌：%s\n", log);
					return true;
				}
				pCards[i] += 2;
				HasCouple = false;
			}
			if (pCards[i] == 4) // 有四个一样的
			{
				pCards[i] -= 4;
				if (IsOneTypeWin(pCards, Num - 4, HasCouple, type))
				{
					sprintf(tmp, "%d%c%d%c%d%c%d%c ", i + 1, g_typedef[type], i + 1, g_typedef[type], i + 1, g_typedef[type], i + 1, g_typedef[type]);
					strcat(log, tmp);
					LOG("当前牌：%s\n", log);
					m_GangNum++;
					return true;
				}
				pCards[i] += 4;
			}
			if (pCards[i] >= 3)
			{
				pCards[i] -= 3;
				if (IsOneTypeWin(pCards, Num - 3, HasCouple, type))
				{
					sprintf(tmp, "%d%c%d%c%d%c ", i + 1, g_typedef[type], i + 1, g_typedef[type], i + 1, g_typedef[type]);
					strcat(log, tmp);
					LOG("当前牌：%s\n", log);
					return true;
				}
				pCards[i] += 3;
			}
			if (i < 7 && pCards[i] && pCards[i + 1] && pCards[i + 2]) // 顺子
			{
				pCards[i] -= 1;
				pCards[i + 1] -= 1;
				pCards[i + 2] -= 1;
				if (IsOneTypeWin(pCards, Num - 3, HasCouple, type))
				{
					sprintf(tmp, "%d%c%d%c%d%c ", i + 1, g_typedef[type], i + 2, g_typedef[type], i + 3, g_typedef[type]);
					strcat(log, tmp);
					LOG("当前牌：%s\n", log);
					return true;
				}
				pCards[i] += 1;
				pCards[i + 1] += 1;
				pCards[i + 2] += 1;
			}
		}
		return false;
	}

private:
	vector<int> m_TypeNum;
	vector<vector<int>> m_CardNum;
	int m_GangNum;  // 杠的数量
	char log[100];  //用作打印log
};
bool IsMahJangWin(char *pCard)
{
	CMahJangg mj;
	mj.Init(pCard);
	return mj.IsWin();
}

int main()
{
	char a[100] = "1w1w1w2d3d4d2w3w4w7d8d9d5w5w";
	auto r = IsMahJangWin(a);
	if (r)
	{
		LOG("win!!!!!");
	}
	else
	{
		LOG("Not Win!!!!");
	}
	return 0;
}

以上三种写法都可以运行，需要自取，不懂留言，有空看到尽力回复~

ps：每天都要进步，蛰伏，当遇到风口浪尖，希望能够随风起飞

流浪打工人
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
JAVA麻将胡牌算法深度解析
liu5047853522的专栏
06-30 1731
本文详细的分析如何使用JAVA来实现麻将算法。从基础到进阶层层递进。无论是否有麻将算法经验，看完本篇后，都可以写出麻将胡牌算法。
C++麻将胡牌算法
08-29
时间复杂弃为 O(n) 可谓原地工作的 C++ 麻将胡牌 算法
PythonMahjong:用Python实现的麻将游戏
04-10
Python麻将 用Python实现的麻将游戏 在控制台上播放 运行mahjong_template_debug.py来查看机器人与机器人的对抗。 若要播放，请将GameManager（）中的参数之一从Player（n）替换为HumanPlayer（n）。 在GUI上播放 GUI正在建设中
麻将程序源码
04-04
一个简单的麻将程序源码，可以局域网对战，喜欢的朋友可以下载研究下
麻将源代码
08-14
麻将源代码里边有很多个麻将的规则 基于java+unity实现的，个人感觉值得学习
MajsoulAI:以JianYangAI作后端，进行在线雀魂对局
05-05
MajsoulAI MajsoulAI项目旨在实现在《雀魂》中用AI代替玩家打麻将。MajsoulAI前端使用通过监听《雀魂》websocket对局信息作为输入，以基于图像识别的模拟鼠标点击作为输出。MajsoulAI后端桥接至一个开源的天凤麻将AI()。 使用说明 运行环境 运行时环境推荐使用，以Win10系统python 3.7.7版本为例，首先建立一个venv环境并激活： $python -m venv ./venv $cmd $.\venv\Scripts\activate.bat 然后安装必要的依赖： $python -m pip install --upgrade pip $pip install -r requirements.txt 一个特殊的依赖是pytorch，由于其版本与安装方式经常变化，建议参考选择合适的版本的安装命令，例如当前最新的Windows-Pip-Cuda
c++麻将胡牌算法，癞子胡牌算法
04-02
麻将，癞子 胡牌 算法，基于c++代码实现，回溯算法
C++麻将游戏算法深入解析
行者无疆 Happy Programming!
11-20 8640
C++麻将游戏算法深入解析           这两天为了工具箱的完善，整理了这些年引擎开发的一些资料，无意中发现06年写的一个麻将算法，编译运行了一下，还是有点意思的，拿出来整理一下分享给大家。          麻将是一种大家最喜爱的娱乐活动之一，相信所有人都有接触过。我写的这版算法，是可以吃，碰，杠，还有把牌摸完没有人胡时的皇庄和包听。是用控制台方式来表现的，什
麻将胡牌算法（C++版）
qq_41810721的博客
12-11 3205
麻将胡牌算法1、麻将的基本规则2、胡牌算法解析牌堆转换 1、麻将的基本规则 常见的麻将一共有三种花色，条、筒、万。每种花色的牌都有1~9个数值，每种数值的牌有4张，总共有493=108张牌。胡牌时手牌必须满足（不包含特殊牌型，如对对胡，大对子等）3ABC+3DDD+EE，即一对将牌除开，剩余的牌全能组成顺子（ABC）或者刻子(DDD)。 2、胡牌算法解析 注：以下分析不包含特殊牌型，如对对胡，大对...
C++实现麻将基本听牌胡牌的算法
热门推荐
sdghchj的博客
08-03 1万+
c++实现麻将的基本胡牌与听牌算法，包括小七对和十三幺牌型。
麻将胡牌算法的判定函数
04-26
非常精辟的胡牌判定方法，同一牌型如果能拆成多种胡牌方式，取番值大的，比如22333444555999，会拆成22,333,444,555,999，而不是234,234,345,55,999
幼麟棋牌社区版 1.2
06-24
幼麟棋牌社区版，是幼麟棋牌的开源版本，用于提供给大家学习游戏服务器编程和客户端编程。 在此之前，幼麟棋牌早已开源在Cocos社区，造成了不小的影响力。 已有不下百个团队或者个人在使用本套代码开发作品。 使用幼麟棋牌框架开发出来的产品更是无法统计，抛开幼麟科技官方的数十款不算，第三方已上线产品不下百款。 幼麟棋牌框架被业内众多爱好者评为 业界清流。 它打破了早期的C++为主的棋牌格局。开创了新一代的纯Javascript脚本模式。 同时也是目前唯一能够一次开发，同时发布iOS,Android,H5三端的棋牌框架。由于其纯脚本特性，在发布iOS和Android时，天然支持热更新功能。 有了幼麟棋牌的动静，业内也有部分团队开始以棋牌平台为主打，建立开源社区，希望在开源社区找到新的盈利模式。 幼麟棋牌社区版包含功能如下： 完整的服务器客户端源代码，搭建后即可运行 完整的房卡棋牌玩法（加入，创建房间） 完整的四川麻将玩法（血战到底，血流成河两种模式） 房卡战绩记录 微信登陆，微信分享 断线重连 适合人群： 想通过完整案例，快速入手游戏开发 想通过完整源码，快速开发棋牌游戏 想通过完整源码，快速开发麻将游戏 想替换一下美术资源，就拥有一款四川麻将 想直接打个包，就拥有一款四川麻将
各种语言的麻将胡牌算法。干货。 c++ c# lua go js麻将胡牌算法.zip
08-18
各种语言的麻将胡牌算法。干货。 c++ c# lua go js麻将胡牌算法.zip
tensorflow麻将智能出牌源码
10-23
用tensorflow写的麻将智能出牌的打码，实现传入手牌后自动选择应该出的牌。
四川麻将胡牌算法
06-12
通过递归的算法实现四川麻将的胡牌算法，这里讲所有的牌进行排序，并调用递归的算法，判定这十四张牌是否能胡，能够成功运行。
C语言四川麻将算法,四川麻将胡牌算法
weixin_42295528的博客
05-23 2219
满意答案四川麻将中基础牌型和杠一起计费。最后输赢为两项之和。基础牌型(格)与基本番数：平胡：普通的四个搭子一对将。如：123 345 789万 234 66筒(1番)大对子(对子胡)：四个搭子均为三张一样的牌。如：111 333 444万222 66筒(2番)清一色：胡牌时只有一色牌。如：111 234 345 666 88万(4番)清大对(清对)：清一色大对子(8番)暗(音ngàn)七对：特殊胡...
成都麻将胡牌算法
weixin_30243533的博客
12-01 944
//四川麻将胡牌算法（不支持风、花牌）:支持缺一门,七小对，正常胡牌，带杠//感谢 华仔 对我的代码提出了宝贵的意见，华仔很适合做测试啊！！#include <stdio.h>#include <memory.h>#include <string.h>#define TEST 0#if TEST#define LOG(fmt, ...) printf(fmt"\...
关于C++麻将胡牌算法的问题
weixin_42719696的博客
08-24 260
最近在网上下载了一个用C++写的麻将程序，研究了两天，发现其中的胡牌算法存在问题，现象是总是不能胡牌。现把算法部分代码贴出来看看，你们能发现问题在哪吗？ //胡牌函数 int CardCanHu(int IsPlayerOrPC) { int length = Player.size() - 1; int first = 0; while (first != length) { for (int second = first + 1; second &...
python麻将胡牌算法
最新发布
01-10
对于Python麻将胡牌算法，可以根据麻将的规则和要求进行编程实现。以下是一个简单的示例代码： ```python def is_valid_hand(hand): # 判断手牌是否合法 # 实现逻辑... def is_valid_meld(meld): # 判断刻子或顺子是否合法 # 实现逻辑... def can_win(hand, melds): # 判断是否能胡牌 # 实现逻辑... # 示例手牌和刻子/顺子 hand = [1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9, 1, 1] melds = [[1, 1, 1], [2, 3, 4]] if is_valid_hand(hand) and all(is_valid_meld(meld) for meld in melds): if can_win(hand, melds): print("可以胡牌") else: print("不能胡牌") else: print("手牌或刻子/顺子不合法") ``` 这个示例代码中，我们定义了三个函数：`is_valid_hand`用于判断手牌是否合法，`is_valid_meld`用于判断刻子或顺子是否合法，`can_win`用于判断是否能胡牌。根据具体的麻将规则和要求，你可以在这些函数中实现相应的逻辑。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值