麻将番型计算（二人麻将）

最新推荐文章于 2024-12-30 14:24:12 发布
最新推荐文章于 2024-12-30 14:24:12 发布
阅读量1.5w 收藏 11
点赞数 6
分类专栏： 算法 文章标签： 麻将番型 二人麻将 番型算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ywloveb/article/details/86570054
版权

上一篇文章序数了关于使用索引查表法进行麻将胡牌判定，这篇文章，我们将会对胡牌的番型进行计算，这里的番型指的是国标下的麻将番型，文章中的代码，暂时只考虑了二人麻将（只有万牌和字牌），想要通用，可以按着同样的方法进行扩展。

国标二人麻将番型表

88番

番型胡牌方式示例
大四喜胡牌时，牌里有4组风刻子（杠）加一对将牌组成的牌型。（不计门风刻、圈风刻、小四喜、三风刻、碰碰胡、幺九刻）在这里插入图片描述
大三元胡牌时，牌里有中、发、白3副刻子。（不计双箭刻、箭刻）在这里插入图片描述
九莲宝灯由一种花色序数组成的特定牌型，见同花色任何一张序数牌即成胡牌。不计清一色，门前清，自摸在这里插入图片描述
大七星胡牌为七对子，并且由“东南西北中发白“其中字牌构成，不计七对，三元七对，四喜七对，全带幺，单钓将，门前清，自摸，字一色在这里插入图片描述
四杠4个杠，不计三杠，双明杠，明杠，单钓将在这里插入图片描述
连七对由一种花色序数牌组成序数相连的7个对子的胡牌。不计七对，单钓将，门前清，自摸，清一色在这里插入图片描述
天胡庄家在发完牌就胡牌。如果庄家有补花，在补完花后就胡牌也算。如果庄家在发完牌后有暗杠， 那么不算天和，不计边张，坎张单钓将不求人，和绝张，自摸
地胡闲家摸到第一张牌 就胡牌，称为地和。如果闲家抓的第一张牌是花牌，那么补花之后胡牌也算地和。如果闲家抓牌前有人吃碰杠(包括暗杠)，那么不算地和。

64番

番型胡牌方式示例
小四喜胡牌时，牌里有风牌的3副刻子及将牌。不记番:三风刻、幺九刻。在这里插入图片描述
小三元胡牌时，牌里有箭牌的两副刻子及将牌。不记番:箭刻、双箭刻。在这里插入图片描述
字一色字一色:胡牌时，牌型由字牌的刻子(杠)、将组成。不记番:碰碰和、混么九、全带幺、么九刻。在这里插入图片描述
四暗刻胡牌时，牌里有4个暗刻(暗杠)。不记番:门前清、碰碰和、三暗刻、双暗刻、不求人。在这里插入图片描述
一色双龙会胡牌时，牌型由一种花色的两个老少副，5为将牌组成。不记番:平和、七对、清色、一般高、老少副。在这里插入图片描述

48番

番型胡牌方式示例
一色四同顺胡牌时，牌里有一种花色且序数相同的4副顺子。不记番:一色三节高、一般高、四归一，一色三同顺、七对。在这里插入图片描述
一色四节高胡牌时牌里有一种花色且序数依次递增一位数的4副刻子(或杠子)。不记番:一色三同顺、一色三节高、碰碰和。在这里插入图片描述

32番

番型胡牌方式示例
一色四步高胡牌时，牌里有一种花色4副依次递增一位数或依次递增二位数的顺子。不记番:一色三步高。在这里插入图片描述
三杠胡牌时，牌里有3副杠，明杠暗杠均可。在这里插入图片描述
混幺九胡牌时，由字牌和序数牌、九的刻子及将牌组成的牌型。不记番:碰碰和、幺九刻、全带么。在这里插入图片描述

24番

番型胡牌方式示例
七对胡牌时，胡牌时，牌型由7个对子组成。（不计门前清、不求人、单钓将）在这里插入图片描述
清一色胡牌时，牌型由一种花色的顺序牌组成。在这里插入图片描述
一色三同顺胡牌时，牌里有一种花色且依次递增一位数字的3副刻子。不记番： 一色三节高、一般高在这里插入图片描述
一色三节高胡牌时，牌里有一种花色且依次递增一位数字的3副刻子。不记番： 一色三同顺在这里插入图片描述

16番

番型胡牌方式示例
清龙胡牌时，有一种相同花色的123，456，789三付顺子即可。清龙就是清一色条龙。不记番:连6、老少副。在这里插入图片描述
一色三步高胡牌时，牌里有一种花色的牌，依次递增一位或依次递增二位数字的3副顺子。三暗刻:胡牌时，牌里有3个暗刻。不记番:双暗刻。在这里插入图片描述
天听庄家打出第-张牌时报听称为天听;发完牌后闲家便报听也称为天听。天听要在胡牌后才算番。如果庄家在发完牌后有暗杠，则庄家不算天听。如果发完牌之后有补花，补花之后报听也算天听。
三暗刻胡牌时，牌里有3个暗刻。在这里插入图片描述

12番

番型胡牌方式示例
大于5胡牌时，牌型由序数牌6 9的顺子、刻子、将牌组成。在这里插入图片描述
小于5胡牌时，牌型由序数牌1-4的顺子、刻子、将牌组成。在这里插入图片描述
三风刻胡牌时，牌里有3个风刻。在这里插入图片描述

8番

番型胡牌方式示例
妙手回春自摸牌墙上最后一张牌胡牌。不记番: 自摸。
海底捞月和打出的最后一张牌。
杠上开花胡牌时，开杠抓进的牌成胡牌。不记番:自摸。
抢杠胡胡牌时，和别人自抓开明杠的牌。不记番:胡绝张。

6番

番型胡牌方式示例
碰碰胡胡牌时，牌型由4副刻子(或杠)、将牌组成。在这里插入图片描述
双暗杠胡牌时，有2个暗杠。在这里插入图片描述
混一色胡牌时，牌型由一种花色序数牌及字牌组成。在这里插入图片描述
全求人胡牌时，全靠吃牌、碰牌、单钓别人打出的牌胡牌。不记番:单钓。在这里插入图片描述
双箭刻胡牌时，牌里有2副箭刻(或杠)。不记番:箭刻。在这里插入图片描述

4番

番型胡牌方式示例
全带幺胡牌时，每副牌、将牌都有么牌。(胡牌时各组牌除了字牌都必须有一或九的序数牌)。在这里插入图片描述
不求人胡牌时，4副牌及将中没有吃牌、碰牌(包括明杠)，自摸胡牌。
双明杠胡牌时，牌里有2个明杠。不记番:明杠。在这里插入图片描述
和绝张胡牌时，胡牌池、桌面已亮明的3张牌所剩的第4张牌。

2番

番型胡牌方式示例
箭刻胡牌时，牌里有中、发、白，这3个牌中的任一个牌组成的1副刻子。在这里插入图片描述
门风刻胡牌时牌里有与门风相同的风刻。
门前清没有吃、碰、明杠，和别人打出的牌。
平胡胡牌时，牌型由4副顺子及序数牌作将组成。边、坎、钓不影响平和。
四归一胡牌时，牌里有4张相同的牌归于一家的顺、刻子、对、将牌中(不包括杠牌)。双暗刻:胡牌时，牌里有2个暗刻。在这里插入图片描述
双暗刻胡牌时，牌里有2个暗刻。
暗杠胡牌时，牌里有一副自抓4张相同的牌且开杠。
断幺胡牌时，牌里没有一、九牌及字牌。在这里插入图片描述
报听报听后胡牌。

1番

番型胡牌方式示例
一般高胡牌时，牌里有一种花色且序数相同的2副顺子。在这里插入图片描述
连六一种花色六张序数相连的顺子(例如: 3-4-5条和6-7-8条)在这里插入图片描述
老少副胡牌时，牌里花色相同的123、789的顺子各一副。在这里插入图片描述
幺九刻胡牌时，牌里有序数为一、九的一副刻子(杠)或是字牌的一副刻子(杠)。在这里插入图片描述
明杠自己有暗刻，碰别人打出的一张相同的牌开杠:或自己抓进一张与碰的明刻相同。在这里插入图片描述
边张单和123的3及789的7或1233和3、7789和7都为边张。手中有12345和3，56789和7不算边张。在这里插入图片描述
坎张胡牌时，和2张牌之间的牌。4556和5也为坎张，手中有45567和6不算坎张。在这里插入图片描述
单钓将钓单张牌作将成和。在这里插入图片描述
自摸自己抓进牌成胡牌。
二五八将胡牌时，将牌是二万、五万、八万。

番型计算

在上一篇文章中提到的查表法进行胡牌判定，其中查表法会给我们提供两个返回值，一个是是否胡牌的布尔值，还有一个是胡牌类型返回结果(MahjongResult)：

//牌型结果
type MahjongResult struct {
	Num_ke     int    //刻子数量
	Num_shun   int    //顺子数量
	Jiang      byte   //将牌值
	Array_ke   []byte //刻子数组
	Array_shun []byte //顺子数组
	Qidui      bool   //是否七对
	Tongtian   bool   //是否通天
}

右手牌（吃碰杠）:

//一组牌
type Meld struct {
	Key    byte       //Key牌 牌面值
	Kind   WEAVE_KIND //组牌类型
	Ids    []byte     //id 数组 唯一id
	Values []byte     //牌面值 数组
	Sites  []byte     //座位 数组
}

结合右手牌（吃碰杠）信息，将每一种胡牌牌型统计成一个结构体：

//统计一种胡牌类型麻将角色（刻子等）
type MahjongCount struct {
	Jiang        byte   //将牌值
	Array_ke     []byte //刻子数组 只列第一个 索引(包含暗刻 和碰)
	Array_a_ke   []byte //暗刻
	Array_shun   []byte //顺子数组 只列第一个
	Array_c_shun []byte //吃牌获得的顺子
	Array_h_shun []byte //手牌中的顺子
	Array_gang   []byte //杠数组 只列第一个 (包含明杠 暗杠)
	Array_m_gang []byte //明杠
	Array_a_gang []byte //暗杠
	TileIndexs   []byte //玩家所有牌  索引
	QiDui        bool   //是否七对
	TongTian     bool   //是否通天
	Zimo         bool   //	是否自摸
	HuId         byte   //	胡牌那张 唯一id
	HuIndex      byte   //胡得那张牌得索引
	MenFeng      byte   //当前胡牌玩家门风（庄为0x31东 闲家为 033西）
	TingBool     bool   //是否报听
}

转换代码:

//将麻将 手牌 和右手牌统一到MahjongCount，每一个MahjongCount都是一种胡牌牌型
func CountMahjongResult(results []*MahjongResult, meld []*Meld, tileIndexs []byte, zimo bool, huId, huIndex, menFeng byte, baoTing bool) []*MahjongCount {
	res := make([]*MahjongCount, 0)
	if results != nil && len(results) > 0 {
		//遍历手牌
		for _, v := range results {
			mc := &MahjongCount{}
			mc.Zimo = zimo
			mc.HuId = huId
			mc.HuIndex = huIndex
			mc.TingBool = baoTing
			mc.TileIndexs = make([]byte, len(tileIndexs))          //初始化tiles
			mc.TileIndexs = append(mc.TileIndexs, tileIndexs...)                          //将tilesIndexs值复制给 tiles
			mc.QiDui = v.Qidui                                     //是否七对
			mc.TongTian = v.Tongtian                               //是否通天
			mc.Jiang = v.Jiang                                     //将牌
			mc.MenFeng = menFeng                                   //门风
			mc.Array_ke = append(mc.Array_ke, v.Array_ke...)       //暗刻
			mc.Array_a_ke = append(mc.Array_a_ke, v.Array_ke...)   //暗刻
			mc.Array_shun = append(mc.Array_shun, v.Array_shun...) //顺子
			mc.Array_h_shun = append(mc.Array_h_shun, v.Array_shun...)
			res = append(res, mc)
		}
	}
	//遍历右手牌
	if meld != nil && len(meld) > 0 {
		for _, m := range meld {
			index := ValueToIndex(m.Values[0])

			if len(res) == 0 {
				mc := &MahjongCount{}
				mc.Zimo = zimo
				mc.HuId = huId
				mc.HuIndex = huIndex
				mc.MenFeng = menFeng //门风
				mc.TingBool = baoTing
				mc.TileIndexs = make([]byte, len(tileIndexs)) //初始化tiles
				mc.TileIndexs = append(mc.TileIndexs, tileIndexs...)                 //将tilesIndexs值复制给 tiles
				res = append(res, mc)
			}
			for _, v := range res {

				//右手 牌类型为左吃 或右吃或中吃
				if m.Kind == KIND_LEFT || m.Kind == KIND_RIGHT || m.Kind == KIND_CENTER {
					v.Array_shun = append(v.Array_shun, index) //将顺子添加到count中
					v.Array_c_shun = append(v.Array_c_shun, index)
					for _, m := range m.Values {
						v.TileIndexs[ValueToIndex(m)] ++
					}
				} else if m.Kind == KIND_PENG { //如果右手牌是 刻子
					v.Array_ke = append(v.Array_ke, index)
					v.TileIndexs[index] += 3
				} else if m.Kind == KIND_GANG || m.Kind == KIND_ANGANG || m.Kind == KIND_JIAGANG { //如果右手牌是 明杠或者暗杠
					v.Array_gang = append(v.Array_gang, index)
					//将右手牌加入到所有牌中
					v.TileIndexs[index] += 4
					if m.Kind == KIND_ANGANG { //暗杠
						v.Array_a_gang = append(v.Array_a_gang, index)
					} else { //明杠
						v.Array_m_gang = append(v.Array_m_gang, index)
					}
				}
			}
		}
	}
	for _, v := range res {
		sortByte(v.Array_ke)
		sortByte(v.Array_gang)
		sortByte(v.Array_shun)
		sortByte(v.Array_m_gang)
		sortByte(v.Array_a_ke)
		sortByte(v.Array_a_gang)
		sortByte(v.Array_c_shun)
	}
	return res
}

//升序排序
func sortByte(a []byte) {
	for i := 0; i < len(a); i++ {
		l := len(a)
		for j := i + 1; j < l; j++ {
			if a[i] > a[j] {
				temp := a[j]
				a[j] = a[i]
				a[i] = temp
			}
		}
		l--
	}
}

进过统计之后的牌型，只需要遍历所有番型进行判断即可。
由于番型种类过多，所以这里我们将函数写进map中，通过遍历这个map对其进行判断。番型返回的结果是一个二进制掩码，这里的番型有62种，所以我们可以使用int64位数对番型进行表示，一位二进制代表着一种番型。同时再使用一种排除番型，表示不能胡某种番。番型二进制掩码表示如下：

package mahjong

//胡牌掩码 null表示没有胡牌(试用二进制表示 1位代表胡牌)
const NULL = int64(0)
const (
	// 二五八将 1
	ERWUBAJIANG = int64(1) << iota
	// 自摸 10
	ZIMO
	// 单调将 100
	DANDIAOJIANG
	// 坎张 1000
	KANZHANG
	// 边张 10000
	BIANZHANG
	// 明杠100000
	MINGGANG
	// 幺九刻 1000000
	YAOJIUKE
	// 老少副 10000000
	LAOSHAOFU
	// 连六 100000000
	LIANLIU
	// 一般高 1000000000
	YIBANGAO
	// 2f番
	// 报听 10000000000
	BAOTING
	// 断幺 100000000000
	DUANYAO
	// 暗杠 13 2
	ANGANG
	// 双暗刻 14 2
	SHUANGANKE
	// 四归一 15 2
	SIGUIYI
	// 平胡 16 2
	PINGHU
	// 门前清 17 2
	MENQIANQING
	// 门风刻 18 2
	MENFENGKE
	// 箭刻 19 2
	JIANKE
	// 4fan
	// 和绝张 20 4
	HUJUEZHANG
	// 双明杠 21 4
	SHUANGMINGGANG
	// 不求人 22 4
	BUQIUREN
	// 全带幺 23 4
	QUANDAIYAO
	// 6fan
	// 双箭刻 24 6
	SHUANGJIANKE
	// 全求人 25 6
	QUANQIUREN
	// 混一色 26 6
	HUNYISE
	// 双暗杠 27 6
	SHUANGANGANG
	// 碰碰胡 28 6
	PENGPENGHU
	// 8fan
	// 抢杠胡 29 8
	QIANGGANGHU
	// 杠上开花 30 8
	GANGSHANGKAIHUA
	// 海底捞月 31 8
	HAIDILAOYUE
	// 妙手回春 32 8
	MIAOSHOUHUICHUN
	// 12fan
	// 三风刻 33 12
	SANFENGKE
	// 小于五 34 12
	XIAOYUWU
	// 大于五 35 12
	DAYUWU
	// 16fan
	// 三暗刻 36 16
	SANANKE
	// 天听 37 16
	TIANTING
	// 一色三步高 38 16
	YISESANBUGAO
	// 清龙 39 16
	QINGLONG
	// 24fan
	// 一色三节高 40 24
	YISESANJIEGAO
	// 一色三同顺 41 24
	YISESANTONGSHUN
	// 清一色 42 24
	QINGYISE
	// 七对 43 24
	QIDUI
	// 32fan
	// 混幺九 44 32
	HUNYAOJIU
	// 三杠 45 32
	SANGANG
	// 一色四步高 46 32
	YISESIBUGAO
	// 48fan
	// 一色四节高 47 48
	YISESIJIEGAO
	// 一色四同顺 48 48
	YISESITONGSHUN
	// 64fan
	// 一色双龙会 49 64
	YISESHUANGLONGHUI
	// 四暗刻 50 64
	SIANKE
	// 字一色 51 64
	ZIYISE
	// 小三元 52 64
	XIAOSANYUAN
	// 小四喜 53 64
	XIAOSIXI

	// 88fan
	// 地胡 55 88
	DIHU
	// 天胡 56 88
	TIANHU
	// 连七对 57 88
	LIANQIDUI
	// 四杠 58 88
	SIGANG
	// 大七星 59 88
	DAQIXING
	// 九宝莲灯 60 88
	JIUBAOLIANDENG
	// 大三元 61 88
	DASANYUAN
	// 大四喜 62 88
	DASIXI
)

//胡牌番型判断切片
var HuType_slice = []int64 {
	DASIXI,
	DASANYUAN,
	JIUBAOLIANDENG,
	DAQIXING,
	SIGANG,
	LIANQIDUI,
	XIAOSIXI,
	XIAOSANYUAN,
	ZIYISE,
	SIANKE,
	YISESHUANGLONGHUI,
	YISESITONGSHUN,
	YISESIJIEGAO,
	YISESIBUGAO,
	SANGANG,
	HUNYAOJIU,
	QIDUI,
	QINGYISE,
	YISESANTONGSHUN,
	YISESANJIEGAO,
	QINGLONG,
	YISESANBUGAO,
	TIANTING,
	SANANKE,
	DAYUWU,
	XIAOYUWU,
	SANFENGKE,
	MIAOSHOUHUICHUN,
	HAIDILAOYUE,
	GANGSHANGKAIHUA,
	PENGPENGHU,
	SHUANGANGANG,
	HUNYISE,
	QUANQIUREN,
	SHUANGJIANKE,
	QUANDAIYAO,
	BUQIUREN,
	HUJUEZHANG,
	JIANKE,
	MENFENGKE,
	MENQIANQING,
	PINGHU,
	SIGUIYI,
	SHUANGANKE,
	ANGANG,
	DUANYAO,
	BAOTING,
	YIBANGAO,
	LIANLIU,
	LAOSHAOFU,
	YAOJIUKE,
	MINGGANG,
	BIANZHANG,
	KANZHANG,
	DANDIAOJIANG,
	ZIMO,
	ERWUBAJIANG,
}

//胡牌掩码 对应的胡牌名称
var HuType_name = map[int64]string{
	NULL:              "NULL",
	ERWUBAJIANG:       "ERWUBAJIANG",
	ZIMO:              "ZIMO",
	DANDIAOJIANG:      "DANDIAOJIANG",
	KANZHANG:          "KANZHANG",
	BIANZHANG:         "BIANZHANG",
	MINGGANG:          "MINGGANG",
	YAOJIUKE:          "YAOJIUKE",
	LAOSHAOFU:         "LAOSHAOFU",
	LIANLIU:           "LIANLIU",
	YIBANGAO:          "YIBANGAO",
	BAOTING:           "BAOTING",
	DUANYAO:           "DUANYAO",
	ANGANG:            "ANGANG",
	SHUANGANKE:        "SHUANGANKE",
	SIGUIYI:           "SIGUIYI",
	PINGHU:            "PINGHU",
	MENQIANQING:       "MENQIANQING",
	MENFENGKE:         "MENFENGKE",
	JIANKE:            "JIANKE",
	HUJUEZHANG:        "HUJUEZHANG",
	SHUANGMINGGANG:    "SHUANGMINGGANG",
	BUQIUREN:          "BUQIUREN",
	QUANDAIYAO:        "QUANDAIYAO",
	SHUANGJIANKE:      "SHUANGJIANKE",
	QUANQIUREN:        "QUANQIUREN",
	HUNYISE:           "HUNYISE",
	SHUANGANGANG:      "SHUANGANGANG",
	PENGPENGHU:        "PENGPENGHU",
	QIANGGANGHU:       "QIANGGANGHU",
	GANGSHANGKAIHUA:   "GANGSHANGKAIHUA",
	HAIDILAOYUE:       "HAIDILAOYUE",
	MIAOSHOUHUICHUN:   "MIAOSHOUHUICHUN",
	SANFENGKE:         "SANFENGKE",
	XIAOYUWU:          "XIAOYUWU",
	DAYUWU:            "DAYUWU",
	SANANKE:           "SANANKE",
	TIANTING:          "TIANTING",
	YISESANBUGAO:      "YISESANBUGAO",
	QINGLONG:          "QINGLONG",
	YISESANJIEGAO:     "YISESANJIEGAO",
	YISESANTONGSHUN:   "YISESANTONGSHUN",
	QINGYISE:          "QINGYISE",
	QIDUI:             "QIDUI",
	HUNYAOJIU:         "HUNYAOJIU",
	SANGANG:           "SANGANG",
	YISESIBUGAO:       "YISESIBUGAO",
	YISESIJIEGAO:      "YISESIJIEGAO",
	YISESITONGSHUN:    "YISESITONGSHUN",
	YISESHUANGLONGHUI: "YISESHUANGLONGHUI",
	SIANKE:            "SIANKE",
	ZIYISE:            "ZIYISE",
	XIAOSANYUAN:       "XIAOSANYUAN",
	XIAOSIXI:          "XIAOSIXI",
	DIHU:              "DIHU",
	TIANHU:            "TIANHU",
	LIANQIDUI:         "LIANQIDUI",
	SIGANG:            "SIGANG",
	DAQIXING:          "DAQIXING",
	JIUBAOLIANDENG:    "JIUBAOLIANDENG",
	DASANYUAN:         "DASANYUAN",
	DASIXI:            "DASIXI",
}

//胡牌对应的番值
var HuType_Fan_Value = map[string]int32{
	"NULL":              0,
	"ERWUBAJIANG":       1,
	"ZIMO":              1,
	"DANDIAOJIANG":      1,
	"KANZHANG":          1,
	"BIANZHANG":         1,
	"MINGGANG":          1,
	"YAOJIUKE":          1,
	"LAOSHAOFU":         1,
	"LIANLIU":           1,
	"YIBANGAO":          1,
	"BAOTING":           2,
	"DUANYAO":           2,
	"ANGANG":            2,
	"SHUANGANKE":        2,
	"SIGUIYI":           2,
	"PINGHU":            2,
	"MENQIANQING":       2,
	"MENFENGKE":         2,
	"JIANKE":            2,
	"HUJUEZHANG":        4,
	"SHUANGMINGGANG":    4,
	"BUQIUREN":          4,
	"QUANDAIYAO":        4,
	"SHUANGJIANKE":      6,
	"QUANQIUREN":        6,
	"HUNYISE":           6,
	"SHUANGANGANG":      6,
	"PENGPENGHU":        6,
	"QIANGGANGHU":       8,
	"GANGSHANGKAIHUA":   8,
	"HAIDILAOYUE":       8,
	"MIAOSHOUHUICHUN":   8,
	"SANFENGKE":         12,
	"XIAOYUWU":          12,
	"DAYUWU":            12,
	"SANANKE":           16,
	"TIANTING":          16,
	"YISESANBUGAO":      16,
	"QINGLONG":          16,
	"YISESANJIEGAO":     24,
	"YISESANTONGSHUN":   24,
	"QINGYISE":          24,
	"QIDUI":             24,
	"HUNYAOJIU":         32,
	"SANGANG":           32,
	"YISESIBUGAO":       32,
	"YISESIJIEGAO":      48,
	"YISESITONGSHUN":    48,
	"YISESHUANGLONGHUI": 64,
	"SIANKE":            64,
	"ZIYISE":            64,
	"XIAOSANYUAN":       64,
	"XIAOSIXI":          64,
	"DIHU":              88,
	"TIANHU":            88,
	"LIANQIDUI":         88,
	"SIGANG":            88,
	"DAQIXING":          88,
	"JIUBAOLIANDENG":    88,
	"DASANYUAN":         88,
	"DASIXI":            88,
}

番型掩码确定后就可以定义函数，

//判定胡牌类型 函数集合 key值为胡牌类型掩码，value为func
var funcFan map[int64]func(countResults *mahjong.MahjongCount, mask, noMask *int64)

胡牌番型判定只需遍历这个函数:

//计算胡牌 类型
func CountHuFan(countResults []*mahjong.MahjongCount) (int64, int64) {
	mask := make([]int64, len(countResults))   //胡牌掩码
	noMask := make([]int64, len(countResults)) //不能胡牌型 掩码
	//遍历所有类型
	maxMask := int64(0)
	maxNoMask := int64(0)
	for k, v := range countResults { //遍历结果
		for _, i := range mahjong.HuType_slice {
			if noMask[k]&i > 0 { //判断当前牌型是否可以胡
				continue
			}
			f, ok := funcFan[i]
			if !ok {
				//fmt.Println("没有此牌型：", i)
				continue
			}
			f(v, &mask[k], &noMask[k]) //调用对应函数 判断是否是此类型胡牌
		}
		if mask[k] > maxMask {
			maxMask = mask[k]
			maxNoMask = noMask[k]
		}
	}
	return maxMask, maxNoMask
}

番型函数的map初始化需要在init函数中进行，

//初始化
func init() {
	funcFan = make(map[int64]func(countResults *mahjong.MahjongCount, mask, noMask *int64), len(mahjong.HuType_slice))
	funcFan[mahjong.DASIXI] = IsBigFourHappy                 //大四喜
	funcFan[mahjong.DASANYUAN] = IsDaSanYuan                 //大三元
	funcFan[mahjong.JIUBAOLIANDENG] = IsJiuLianBaoDeng       //九莲宝灯
	funcFan[mahjong.DAQIXING] = IsDaQiXing                   //大七星
	funcFan[mahjong.SIGANG] = IsSiGang                       //四杠
	funcFan[mahjong.LIANQIDUI] = IsLianQiDui                 //连七对
	funcFan[mahjong.XIAOSIXI] = IsXiaoSiXi                   //小四喜
	funcFan[mahjong.XIAOSANYUAN] = IsXiaoSanYuan             //小三元
	funcFan[mahjong.ZIYISE] = IsZiYiSe                       //字一色
	funcFan[mahjong.SIANKE] = IsSiAnKe                       //四暗刻
	funcFan[mahjong.YISESHUANGLONGHUI] = IsYiSeShuangLongHui //一色双龙会
	funcFan[mahjong.YISESITONGSHUN] = IsYiSeSiTongShun       //一色四同顺
	funcFan[mahjong.YISESIJIEGAO] = IsYiSeSiJieGao           //一色四节高
	funcFan[mahjong.YISESIBUGAO] = IsYiSeSiBuGao             //一色四步高
	funcFan[mahjong.SANGANG] = IsSanGang                     //三杠
	funcFan[mahjong.HUNYAOJIU] = IsHunYaoJiu                 //混幺九
	funcFan[mahjong.QIDUI] = IsQiDui                         //七对
	funcFan[mahjong.QINGYISE] = IsQingYiSe                   //清一色
	funcFan[mahjong.YISESANTONGSHUN] = IsYiSeSanTongShun     //一色三同顺
	funcFan[mahjong.YISESANJIEGAO] = IsYiSeSanJieGao         //一色三节高
	funcFan[mahjong.QINGLONG] = IsQingLong                   //清龙
	funcFan[mahjong.YISESANBUGAO] = IsYiSeSanBuGao           //一色三步高
	funcFan[mahjong.TIANTING] = IsTianTing                   //天听
	funcFan[mahjong.SANANKE] = IsSanAnKe                     //三暗刻
	funcFan[mahjong.DAYUWU] = IsDaYuWu                       //大于五
	funcFan[mahjong.XIAOYUWU] = IsXiaoYuWu                   //小于五
	funcFan[mahjong.SANFENGKE] = IsSanFengKe                 //三风刻
	funcFan[mahjong.MIAOSHOUHUICHUN] = IsMiaoShouHuiChun     //妙手回春
	funcFan[mahjong.HAIDILAOYUE] = IsHaiDiLaoYue             //海底捞月
	funcFan[mahjong.GANGSHANGKAIHUA] = IsGangShangKaiHua     //杠上开花	上层方法计算
	funcFan[mahjong.QIANGGANGHU] = IsQiangGangHu             //抢杠胡	上层方法计算
	funcFan[mahjong.PENGPENGHU] = IsPengPengHu               //碰碰胡
	funcFan[mahjong.SHUANGANGANG] = IsShuangAnGang           //双暗杠
	funcFan[mahjong.HUNYISE] = IsHunYiSe                     //混一色
	funcFan[mahjong.QUANQIUREN] = IsQuanQiuRen               //全求人
	funcFan[mahjong.SHUANGJIANKE] = IsShuangJianKe           //双箭刻
	funcFan[mahjong.QUANDAIYAO] = IsQuanDaiYao               //全带幺
	funcFan[mahjong.BUQIUREN] = IsBuQiuRen                   //不求人
	funcFan[mahjong.SHUANGMINGGANG] = IsShuangMingGang       //双明杠
	funcFan[mahjong.HUJUEZHANG] = IsHuJueZhang               //胡绝张
	funcFan[mahjong.JIANKE] = IsJianKe                       //箭刻
	funcFan[mahjong.MENFENGKE] = IsMenFengKe                 //门风刻
	funcFan[mahjong.MENQIANQING] = IsMenQianQing             //门前清
	funcFan[mahjong.PINGHU] = IsPingHu                       //平胡
	funcFan[mahjong.SIGUIYI] = IsSiGuiYi                     //四归一
	funcFan[mahjong.SHUANGANKE] = IsShuangAnKe               //双暗刻
	funcFan[mahjong.ANGANG] = IsAnGang                       //暗杠
	funcFan[mahjong.DUANYAO] = IsDuanYao                     //断幺
	funcFan[mahjong.BAOTING] = IsBaoTing                     //报听
	funcFan[mahjong.YIBANGAO] = IsYiBanGao                   //一般高
	funcFan[mahjong.LIANLIU] = IsLianLiu                     //连六
	funcFan[mahjong.LAOSHAOFU] = IsLaoShaoFu                 //老少副
	funcFan[mahjong.YAOJIUKE] = IsYaoJiuKe                   //幺九刻
	funcFan[mahjong.MINGGANG] = IsMingGang                   //明杠
	funcFan[mahjong.BIANZHANG] = IsBianZhang                 //边张
	funcFan[mahjong.KANZHANG] = IsKanZhang                   //坎张
	funcFan[mahjong.DANDIAOJIANG] = IsDanDiaoJiang           //单钓将
	funcFan[mahjong.ZIMO] = IsZiMo                           //自摸
	funcFan[mahjong.ERWUBAJIANG] = IsErWuBaJiang             //二五八将
}

下面是62种番型计算方法:

/**
0 1 2 3 4 5 6 7 8 9  万 索引
27 28 29 30 风
31 32 33 中发白
 */

/**
params:
	results : 判断手牌是否胡牌返回结果
	melds	：右手牌
 */

//大四喜
//胡牌时，牌里有4组风牌刻子（杠）加一对将牌组成的牌型。（不计门风刻、圈风刻、小四喜、三风刻、碰碰胡、幺九刻）
func IsBigFourHappy(v *mahjong.MahjongCount, mask, noMask *int64) {
	//判断4组风刻子情况
	//判断手牌中的刻子的情况

	num_ke := len(v.Array_ke)
	num_gang := len(v.Array_gang)
	//一副牌中 刻的数量没有4个 并且 杠的数量也没有4个 必定不是大四喜
	if num_ke != 4 && num_gang != 4 {
		return
	} else {
		//杠或刻子的数量是 4个 ，判断是否是风牌杠
		arr := v.Array_ke
		if num_gang == 4 {
			arr = v.Array_gang
		}
		bo := true
		for _, m := range arr {
			if m < 27 || m > 30 { //杠、刻不是风
				bo = false
				break
			}
		}
		if !bo {
			return
		}
		*mask |= mahjong.DASIXI
		//不计门风刻 小四喜 三风刻 碰碰胡 幺九刻
		*noMask |= mahjong.MENFENGKE | mahjong.XIAOSIXI | mahjong.SANFENGKE | mahjong.PENGPENGHU | mahjong.YAOJIUKE
		return
	}

	return
}

//大三元
//胡牌时，牌里有中、发、白3副刻子。（不计双箭刻、箭刻）
func IsDaSanYuan(v *mahjong.MahjongCount, mask, noMask *int64) {

	lenKe := len(v.Array_ke)
	if lenKe < 3 { // 判断胡牌中 刻子数是否大于三 最多只有4刻子
		return
	}
	//如果有三幅以上刻子  则判断这三幅刻子是否是中 发 白 0x35 0x36 0x37
	//如果刻子数=3，并且第一个不是 中 0x35 或者 刻子数=4，并且第二个刻子不是中0x35
	if (lenKe == 3 && mahjong.IndexToValue(v.Array_ke[0]) != 0x35) || (lenKe == 4 && mahjong.IndexToValue(v.Array_ke[1]) != 0x35) {
		return
	}
	*mask |= mahjong.DASANYUAN
	//排除牌型
	*noMask |= mahjong.SHUANGJIANKE | mahjong.JIANKE

	return
}

//九莲宝灯
//由一种花色序数组成的特定牌型，见同花色任何一张序数牌即成胡牌。不计清一色，门前清，自摸
//牌型为 11123456789999
func IsJiuLianBaoDeng(v *mahjong.MahjongCount, mask, noMask *int64) {

	fmt.Println("jiang:", v.Jiang)
	//判断将牌是否是1
	if v.Jiang != 0 {
		return
	}
	//判断刻子是否是9
	if len(v.Array_ke) != 1 || (v.Array_ke[0] != 8) {
		return
	}
	//判断顺子是否是 1 4 7
	if len(v.Array_shun) != 3 || (v.Array_shun[0] != 0 || v.Array_shun[1] != 3 || v.Array_shun[2] != 6) {
		return
	}
	*mask |= mahjong.JIUBAOLIANDENG
	*noMask |= mahjong.QINGYISE | mahjong.MENQIANQING | mahjong.ZIMO

}

//大七星
//胡牌为七对子，并且由“东南西北中发白“其中字牌构成，不计七对，三元七对，四喜七对，全带幺，单钓将，门前清，自摸，字一色
func IsDaQiXing(v *mahjong.MahjongCount, mask, noMask *int64) {

	if !v.QiDui { //如果不是七对
		return
	}
	//遍历所有牌型，可以从东南西北中发白 处开始遍历
	bo := true
	for i := byte(27); i < mahjong.MAX_INDEX; i++ {
		if v.TileIndexs[i] != 2 {
			bo = false
			break
		}
	}
	if bo {
		*mask |= mahjong.DAQIXING
		*noMask |= mahjong.QIDUI | mahjong.QUANDAIYAO | mahjong.DANDIAOJIANG | mahjong.MENQIANQING | mahjong.ZIMO | mahjong.ZIYISE
	}

}

//四杠
//4个杠，不计三杠，双明杠，明杠，单钓将
func IsSiGang(v *mahjong.MahjongCount, mask, noMask *int64) {

	if len(v.Array_gang) != 4 { //杠的数量没有四个
		return
	}
	*mask |= mahjong.SIGANG
	*noMask |= mahjong.SANGANG | mahjong.SHUANGMINGGANG | mahjong.MINGGANG | mahjong.DANDIAOJIANG

}

//连七对
//由一种花色序数牌组成序数相连的7个对子的胡牌。不计七对，单钓将，门前清，自摸，清一色
func IsLianQiDui(v *mahjong.MahjongCount, mask, noMask *int64) {

	if !v.QiDui { //不是七对
		return
	}
	//判断这七对是否是顺序
	bo := true
	for i := byte(0); i < 9; i++ { //由于是二人麻将，只有一种序数牌（万）,所以只需判断前九个
		if v.TileIndexs[i] != 2 {
			bo = false
			break
		}
	}
	if bo {
		*mask |= mahjong.LIANQIDUI
		*noMask |= mahjong.QIDUI | mahjong.DANDIAOJIANG | mahjong.MENQIANQING | mahjong.QINGYISE
	}

}

//小四喜
//胡牌时，牌里有风牌的3副刻子及将牌。不记番:三风刻、幺九刻。
func IsXiaoSiXi(v *mahjong.MahjongCount, mask, noMask *int64) {

	lke := len(v.Array_ke)
	fmt.Println(v)
	if lke < 3 { //判断刻子数是否小于三
		return
	}
	//判断将牌是否是风牌
	if v.Jiang > 30 || v.Jiang < 27 {
		return
	}
	num := 0
	//判断是否有三个风牌刻子
	for _, m := range v.Array_ke {
		if m >= 27 && m <= 30 {
			num ++
		}
	}
	if num != 3 {
		return
	}
	*mask |= mahjong.XIAOSIXI
	*noMask |= mahjong.SANFENGKE | mahjong.YAOJIUKE

}

//小三元
//胡牌时，牌里有箭牌的两副刻子及将牌。不记番:箭刻、双箭刻
func IsXiaoSanYuan(v *mahjong.MahjongCount, mask, noMask *int64) {

	//将牌必须是箭牌
	if v.Jiang < 31 {
		return
	}
	//刻子数不能少于2副
	if len(v.Array_ke) <= 1 {
		return
	}
	//刻子中有两副是箭牌
	num := 0
	for _, m := range v.Array_ke {
		if m >= 31 {
			num++
		}
	}
	if num < 2 {
		return
	}
	*mask |= mahjong.XIAOSANYUAN
	*noMask |= mahjong.JIANKE | mahjong.SHUANGJIANKE

}

//字一色（字牌 包含风牌（东南西北）和箭牌（中发白））
//胡牌时，牌型由字牌的刻子(杠)、将组成。不记番:碰碰和、混么九、全带幺、么九刻。
func IsZiYiSe(v *mahjong.MahjongCount, mask, noMask *int64) {

	//将牌必须是字牌
	if v.Jiang < 27 {
		return
	}
	//不可能有顺子
	if len(v.Array_shun) > 0 {
		return
	}
	bo := true
	kg := make([]byte, 0)
	kg = append(append(kg, v.Array_ke...), v.Array_gang...)
	//刻子、杠都要为字牌
	for _, m := range kg {
		if m < 27 {
			bo = false
			break
		}
	}
	if !bo {
		return
	}
	*mask |= mahjong.ZIYISE
	*noMask |= mahjong.PENGPENGHU | mahjong.HUNYAOJIU | mahjong.QUANDAIYAO | mahjong.YAOJIUKE
}

//四暗刻
//胡牌时，牌里有4个暗刻(暗杠)。不记番:门前清、碰碰和、三暗刻、双暗刻、不求人。
func IsSiAnKe(v *mahjong.MahjongCount, mask, noMask *int64) {

	//判断暗刻和暗杠数量之和
	if len(v.Array_a_ke)+len(v.Array_a_gang) < 4 {
		return
	}
	*mask |= mahjong.SIANKE
	*noMask |= mahjong.MENQIANQING | mahjong.PENGPENGHU | mahjong.SANANKE | mahjong.SHUANGANKE | mahjong.BUQIUREN
}

//一色双龙会
//胡牌时，牌型由一种花色的两个老少副，5为将牌组成。不记番:平和、七对、清色、一般高、老少副
//老少副：胡牌时，牌里花色相同的123、789的顺子各一副
//二人麻将只有一种情况 1 2 3 1 2 3 5 7 8 9 7 8 9  5
func IsYiSeShuangLongHui(v *mahjong.MahjongCount, mask, noMask *int64) {

	///将牌必须是5
	if v.Jiang != 4 {
		return
	}
	//顺子数必须是4个
	if len(v.Array_shun) != 4 {
		return
	}
	//1 和9 开头的顺子必须都有两个
	num1 := 0
	num9 := 0
	for _, m := range v.Array_shun {
		if m == 0 {
			num1++
		}
		if m == 6 {
			num9++
		}
	}
	if num1 != 2 || num9 != 2 {
		return
	}
	*mask |= mahjong.YISESHUANGLONGHUI
	*noMask |= mahjong.PINGHU | mahjong.QIDUI | mahjong.QINGYISE | mahjong.YIBANGAO | mahjong.LAOSHAOFU

}

//一色四同顺
//牌里有一种花色且序数相同的4副顺子。不记番:一色三节高、一般高、四归一，一色三同顺、七对。
func IsYiSeSiTongShun(v *mahjong.MahjongCount, mask, noMask *int64) {

	//顺子数要4个
	if len(v.Array_shun) != 4 {
		return
	}
	//顺子要一样
	bo := true
	f := v.Array_shun[0]
	for _, m := range v.Array_shun {
		if f != m {
			bo = false
			break
		}
	}
	if !bo {
		return
	}
	*mask |= mahjong.YISESITONGSHUN
	*noMask |= mahjong.YISESANJIEGAO | mahjong.YIBANGAO | mahjong.SIGUIYI | mahjong.YISESANTONGSHUN | mahjong.QIDUI

}

//一色四节高
//胡牌时牌里有一种花色且序数依次递增一位数的4副刻子(或杠子)。不记番:一色三同顺、一色三节高、碰碰和。
func IsYiSeSiJieGao(v *mahjong.MahjongCount, mask, noMask *int64) {

	//杠或者刻子数只能是四个
	if len(v.Array_ke) != 4 && len(v.Array_gang) != 4 {
		return
	}
	a := make([]byte, 0)
	a = v.Array_ke[:]
	if len(v.Array_gang) == 4 {
		a = v.Array_gang[:]
	}
	//最后一个刻或者杠 与第一个杠或者刻相差3（因为Array_ke 和Array_gang是经过排序的）
	if a[3]-a[0] != 3 {
		return
	}
	*mask |= mahjong.YISESIJIEGAO
	*noMask |= mahjong.YISESANTONGSHUN | mahjong.YISESANJIEGAO | mahjong.PENGPENGHU

}

//一色四步高
//胡牌时，牌里有一种花色4副依次递增一位数或依次递增二位数的顺子。不记番:一色三步高。
//递增一位：123 234 345 456 北北  递增两位： 123 345 567 789 北北
func IsYiSeSiBuGao(v *mahjong.MahjongCount, mask, noMask *int64) {

	//顺子数必须是4个
	if len(v.Array_shun) != 4 {
		return
	}
	//	第一个顺子和第二个顺子之间的差
	c := v.Array_shun[1] - v.Array_shun[0]
	if c != 1 && c != 2 { //相差必须是1 或者2
		return
	}
	bo := true
	//从第三个顺子开始判断，
	for i := 2; i < len(v.Array_shun); i++ {
		if v.Array_shun[i]-v.Array_shun[i-1] != c {
			bo = false
			break
		}
	}
	if !bo {
		return
	}
	*mask |= mahjong.YISESIBUGAO
	*noMask |= mahjong.YISESANBUGAO

}

//三杠
//胡牌时，牌里有3副杠，明杠暗杠均可。
func IsSanGang(v *mahjong.MahjongCount, mask, noMask *int64) {

	//必须三幅杠
	if len(v.Array_gang) != 3 {
		return
	}
	*mask |= mahjong.SANGANG

}

//混幺九
//胡牌时，由字牌和序数牌、九的刻子及将牌组成的牌型。不记番:碰碰和、幺九刻、全带么。
func IsHunYaoJiu(v *mahjong.MahjongCount, mask, noMask *int64) {

	//刻子数至少两个
	if len(v.Array_ke) < 2 {
		return
	}
	ziKe := 0
	yjKe := 0
	for _, m := range v.Array_ke {
		if m == 0 || m == 8 {
			yjKe ++
		} else if m > 30 {
			ziKe ++
		}
	}
	if yjKe != 2 {
		return
	}
	if ziKe < 1 {
		return
	}
	*mask |= mahjong.HUNYAOJIU
	*noMask |= mahjong.PENGPENGHU | mahjong.YAOJIUKE | mahjong.QUANDAIYAO

}

//七对
//胡牌时，胡牌时，牌型由7个对子组成。（不计门前清、不求人、单钓将）
func IsQiDui(v *mahjong.MahjongCount, mask, noMask *int64) {

	if !v.QiDui {
		return
	}
	*mask |= mahjong.QIDUI
	*noMask |= mahjong.MENQIANQING | mahjong.BUQIUREN | mahjong.DANDIAOJIANG

}

//清一色
//胡牌时，牌型由一种花色的顺序牌组成
func IsQingYiSe(v *mahjong.MahjongCount, mask, noMask *int64) {

	//检查将牌 刻子 顺子 杠 是否是同一色（二人麻将只需判断是否是万牌）
	if v.Jiang > 8 {
		return
	}
	//最大一个刻必须是万
	if len(v.Array_ke) > 0 && v.Array_ke[len(v.Array_ke)-1] > 8 {
		return
	}
	//最大杠必须是万
	if len(v.Array_gang) > 0 && v.Array_gang[len(v.Array_gang)-1] > 8 {
		return
	}
	//顺子不需要判断，因为二人麻将只有万才会有顺子
	*mask |= mahjong.QINGYISE

}

//一色三同顺
//胡牌时，牌里有一种花色且依次递增一位数字的3副顺子。不记番： 一色三节高、一般高
func IsYiSeSanTongShun(v *mahjong.MahjongCount, mask, noMask *int64) {

	l := len(v.Array_shun)
	//顺子必须三幅以上
	if l < 3 {
		return
	}
	num := 1
	for i := 0; i < l-1; i++ {
		if v.Array_shun[i] == v.Array_shun[i+1] {
			num++
		} else if i == 1 {
			num = 0
		}
	}
	if num < 3 {
		return
	}
	*mask |= mahjong.YISESANTONGSHUN
	*noMask |= mahjong.YISESANJIEGAO | mahjong.YIBANGAO

}

//一色三节高
//胡牌时，牌里有一种花色且依次递增一位数字的3副刻子。不记番： 一色三同顺
func IsYiSeSanJieGao(v *mahjong.MahjongCount, mask, noMask *int64) {

	//刻子数至少是三个
	l := len(v.Array_ke)
	if l < 3 {
		return
	}
	num := 1
	for i := 0; i < l-1; i++ {
		if v.Array_ke[i]+1 == v.Array_ke[i+1] {
			num++
		} else if i == 1 {
			break
		}
	}
	if num < 3 {
		return
	}
	*mask |= mahjong.YISESANJIEGAO
	*noMask |= mahjong.YISESANTONGSHUN

}

//清龙
//胡牌时，有一种相同花色的123，456，789三付顺子即可。清龙就是清一色条龙。不记番:连6、老少副。
func IsQingLong(v *mahjong.MahjongCount, mask, noMask *int64) {

	//顺子至少三个
	l := len(v.Array_shun)
	if l < 3 {
		return
	}
	num1 := false
	num4 := false
	num7 := false
	//遍历顺子，判断是否存在 1 4 7 开头的顺子。
	for _, m := range v.Array_shun {
		if m == 0 {
			num1 = true
		} else if m == 3 {
			num4 = true
		} else if m == 6 {
			num7 = true
		}
	}
	if num1 && num4 && num7 {
		*mask |= mahjong.QINGLONG
		*noMask |= mahjong.LIANLIU | mahjong.LAOSHAOFU
	}

}

//一色三步高
//胡牌时，牌里有一种花色的牌，依次递增一位或依次递增二位数字的3副顺子。
/*
123 234 345 777 3131
123 345 456 567 303030 3131
 */
func IsYiSeSanBuGao(v *mahjong.MahjongCount, mask, noMask *int64) {

	//顺子三个以上
	l := len(v.Array_shun)
	if l < 3 {
		return
	}
	//相差1
	n1 := 0
	n2 := 0
	for i := 0; i < l-1; i++ {
		if v.Array_shun[i+1]-v.Array_shun[i] == 1 {
			n1 ++
		} else if v.Array_shun[i+1]-v.Array_shun[i] == 2 {
			n2 ++
		}
	}
	if n1 < 2 && n2 < 2 {
		return
	}
	c := byte(1)
	if n2 > 1 {
		c = 2
	}
	if l == 3 {
		*mask |= mahjong.YISESANBUGAO
	} else {
		if v.Array_shun[2]-v.Array_shun[1] == c {
			*mask |= mahjong.YISESANBUGAO
		}
	}

}

//天听
///庄家打出第-张牌时报听称为天听;发完牌后闲家便报听也称为天听。天听要在胡牌后才算番。如果庄家在发完牌后有暗杠，则庄家不算天听。如果发完牌之后有补花，补花之后报听也算天听。
func IsTianTing(v *mahjong.MahjongCount, mask, noMask *int64) {

}

//三暗刻
//胡牌时，牌里有3个暗刻。
func IsSanAnKe(v *mahjong.MahjongCount, mask, noMask *int64) {

	//暗刻必须三个
	if len(v.Array_a_ke) < 3 {
		return
	}
	*mask |= mahjong.SANANKE

}

//大于五
//胡牌时，牌型由序数牌6 9的顺子、刻子、将牌组成。（二人麻将只需判断万牌）
func IsDaYuWu(v *mahjong.MahjongCount, mask, noMask *int64) {

	sum := byte(0)
	//判断所有牌索引是否在5-8之间(至少是14张牌）
	for i := 5; i < 9; i++ {
		sum += v.TileIndexs[i]
	}
	if sum < 14 {
		return
	}
	*mask |= mahjong.DAYUWU

}

//小于五
//胡牌时，牌型由序数牌1-4的顺子、刻子、将牌组成。
func IsXiaoYuWu(v *mahjong.MahjongCount, mask, noMask *int64) {

	sum := byte(0)
	for i := 0; i < 5; i++ {
		sum += v.TileIndexs[i]
	}
	if sum < 14 {
		return
	}
	*mask |= mahjong.XIAOYUWU
}

//三风刻
//胡牌时，牌里有3个风刻
func IsSanFengKe(v *mahjong.MahjongCount, mask, noMask *int64) {
	//刻子必须有三个以上
	if len(v.Array_ke) < 3 {
		return
	}
	sum := 0
	for _, m := range v.Array_ke {
		if m < 31 && m > 26 {
			sum++
		}
	}
	if sum > 2 {
		*mask |= mahjong.SANFENGKE
	}
}

//妙手回春
//最后一张牌 ，自摸胡牌。不记番: 自摸。
func IsMiaoShouHuiChun(v *mahjong.MahjongCount, mask, noMask *int64) {
	//必须是自摸
	if !v.Zimo {
		return
	}
	//牌唯一id必须是最后一张
	if v.HuId == MaxTiles-1 {
		*mask |= mahjong.MIAOSHOUHUICHUN
		*noMask |= mahjong.ZIMO
	}
}

//海底捞月
//胡最后一张打出来的牌
func IsHaiDiLaoYue(v *mahjong.MahjongCount, mask, noMask *int64) {
	//不能是自摸
	if v.Zimo {
		return
	}
	//牌必须是最后一张
	if v.HuId == MaxTiles-1 {
		*mask |= mahjong.HAIDILAOYUE
	}
}

//杠上开花
//胡牌时，开杠抓进的牌成胡牌。不记番:自摸。
func IsGangShangKaiHua(v *mahjong.MahjongCount, mask, noMask *int64) {
	//杠上开花在上层计算
}

//抢杠胡
//胡牌时，和别人自抓开明杠的牌。不记番:胡绝张。
func IsQiangGangHu(v *mahjong.MahjongCount, mask, noMask *int64) {
	//抢杠胡在上层计算
}

//碰碰胡
//胡牌时，牌型由4副刻子(或杠)、将牌组成。
func IsPengPengHu(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_ke) != 4 && len(v.Array_gang) != 4 {
		return
	}
	*mask |= mahjong.PENGPENGHU
}

//双暗杠
//胡牌时，有2个暗杠
func IsShuangAnGang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_a_gang) == 2 {
		*mask |= mahjong.SHUANGANGANG
	}
}

//混一色
//胡牌时，牌型由一种花色序数牌及字牌组成
func IsHunYiSe(v *mahjong.MahjongCount, mask, noMask *int64) {
	//
	bo := false
	bo1 := false
	for i := byte(0); i < byte(9); i++ {
		if v.TileIndexs[i] > 0 {
			bo = true
			break
		}
	}
	for i := byte(27); i < mahjong.MAX_INDEX; i++ {
		if v.TileIndexs[i] > 0 {
			bo1 = true
			break
		}
	}
	if bo && bo1 {
		*mask |= mahjong.HUNYISE
	}
}

//全求人
//胡牌时，全靠吃牌、碰牌、单钓别人打出的牌胡牌。不记番:单钓。
func IsQuanQiuRen(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_c_shun) != len(v.Array_shun) || len(v.Array_a_gang) != 0 || len(v.Array_a_ke) != 0 {
		return
	}
	*mask |= mahjong.QUANQIUREN
	*noMask |= mahjong.DANDIAOJIANG
}

//双箭刻
//胡牌时，牌里有2副箭刻(或杠)。不记番:箭刻。
func IsShuangJianKe(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_ke) != 2 && len(v.Array_gang) != 2 {
		return
	}
	var a []byte
	if len(v.Array_ke) == 2 {
		a = v.Array_ke
	} else {
		a = v.Array_gang
	}
	bo := true
	for _, m := range a {
		if m < 31 {
			bo = false
			break
		}
	}
	if bo {
		*mask |= mahjong.SHUANGJIANKE
		*noMask |= mahjong.JIANKE
	}
}

//全带幺
//胡牌时，每副牌、将牌都有么或九牌。(胡牌时各组牌除了字牌都必须有一或九的序数牌)。
func IsQuanDaiYao(v *mahjong.MahjongCount, mask, noMask *int64) {
	//将牌必须是1 或9
	if v.Jiang != 0 && v.Jiang != 8 {
		return
	}
	//顺子中必须有1 或9
	for _, m := range v.Array_shun {
		if m != 0 && m != 7 {
			return
		}
	}
	//刻子、杠必须是1 或者9
	var a []byte
	a = append(append(a, v.Array_ke...), v.Array_shun...)
	for _, m := range a {
		if m != 0 && m != 8 {
			return
		}
	}
	*mask |= mahjong.QUANDAIYAO
}

//不求人
//胡牌时，4副牌及将中没有吃牌、碰牌(包括明杠)，自摸胡牌。
func IsBuQiuRen(v *mahjong.MahjongCount, mask, noMask *int64) {
	//必须是自摸
	if !v.Zimo {
		return
	}
	//不能有吃、碰、和明杠
	if len(v.Array_c_shun) != 0 || len(v.Array_a_ke) != len(v.Array_ke) || len(v.Array_m_gang) != 0 {
		return
	}
	*mask |= mahjong.BUQIUREN
}

//双明杠
//胡牌时，牌里有2个明杠。不记番:明杠。
func IsShuangMingGang(v *mahjong.MahjongCount, mask, noMask *int64) {
	//必须两个明杠
	if len(v.Array_m_gang) != 2 {
		return
	}
	*mask |= mahjong.SHUANGMINGGANG
	*noMask |= mahjong.MINGGANG
}

//胡绝张
//胡牌时，胡牌池、桌面已亮明的3张牌所剩的第4张牌。
func IsHuJueZhang(v *mahjong.MahjongCount, mask, noMask *int64) {
	//在上层实现
}

//箭刻
//胡牌时，牌里有中、发、白，这3个牌中的任一个牌组成的1副刻子
func IsJianKe(v *mahjong.MahjongCount, mask, noMask *int64) {

	for _, m := range v.Array_ke {
		if m > 29 {
			*mask |= mahjong.JIANKE
			return
		}
	}
}

//门风刻
//胡牌时牌里有与门风相同的风刻。
func IsMenFengKe(v *mahjong.MahjongCount, mask, noMask *int64) {
	//刻子
	if len(v.Array_ke) < 1 {
		return
	}
	for _, m := range v.Array_ke {
		if m == v.MenFeng {
			*mask |= mahjong.MENFENGKE
			return
		}
	}
}

//门前清
//没有吃、碰、明杠，和别人打出的牌。
func IsMenQianQing(v *mahjong.MahjongCount, mask, noMask *int64) {
	///不能是自摸
	if v.Zimo {
		return
	}
	if len(v.Array_c_shun) != 0 || len(v.Array_a_ke) != len(v.Array_ke) || len(v.Array_m_gang) != 0 {
		return
	}
	*mask |= mahjong.MENQIANQING
}

//平胡
//胡牌时，牌型由4副顺子及序数牌作将组成。边、坎、钓不影响平和。
func IsPingHu(v *mahjong.MahjongCount, mask, noMask *int64) {
	//将必须是1-9
	if v.Jiang > 8 {
		return
	}
	//顺子有四个
	if len(v.Array_shun) != 4 {
		return
	}
	*mask |= mahjong.PINGHU
}

//四归一
//胡牌时，牌里有4张相同的牌归于一家的顺、刻子、对、将牌中(不包括杠牌)。
func IsSiGuiYi(v *mahjong.MahjongCount, mask, noMask *int64) {
	//找到四张一样的牌（可以排除字牌）
	s := make([]byte, 0)
	for i, m := range v.TileIndexs {
		if m == 4 {
			s = append(s, byte(i))
		}
	}
	//遍历这些四张一样的牌，只要不是杠，就可以
	for _, c := range s {
		bo := true
		for _, k := range v.Array_gang {
			if k == c {
				bo = false
				break
			}
		}
		if bo {
			*mask |= mahjong.SIGUIYI
			return
		}
	}
}

//双暗刻
//胡牌时，牌里有2个暗刻。
func IsShuangAnKe(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_a_ke) == 2 {
		*mask |= mahjong.SHUANGANKE
	}
}

//暗杠
//胡牌时，牌里有一副自抓4张相同的牌且开杠
func IsAnGang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_a_gang) > 0 {
		*mask |= mahjong.ANGANG
	}
}

//断幺
//胡牌时，牌里没有一、九牌及字牌。
func IsDuanYao(v *mahjong.MahjongCount, mask, noMask *int64) {
	//没有1 和9
	if v.TileIndexs[0] != 0 || v.TileIndexs[8] != 0 {
		return
	}
	//判断字牌
	for i := byte(27); i < mahjong.MAX_INDEX; i++ {
		if v.TileIndexs[i] != 0 {
			return
		}
	}
	*mask |= mahjong.DUANYAO
}

//报听
//报听后胡牌。
func IsBaoTing(v *mahjong.MahjongCount, mask, noMask *int64) {
	if v.TingBool {
		*mask |= mahjong.BAOTING
	}
}

//一般高
//胡牌时，牌里有一种花色且序数相同的2副顺子。
func IsYiBanGao(v *mahjong.MahjongCount, mask, noMask *int64) {
	//顺子数 必须是2个以上
	if len(v.Array_shun) < 2 {
		return
	}
	bo := false
	for i, m := range v.Array_shun {
		for j := i + 1; j < len(v.Array_shun); j++ {
			if v.Array_shun[j] == m {
				bo = true
				break
			}
		}
		if bo {
			*mask |= mahjong.YIBANGAO
			return
		}
	}
}

//连六
//一种花色六张序数相连的顺子(例如: 3-4-5条和6-7-8条)
func IsLianLiu(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_shun) < 2 {
		return
	}
	for i := 0; i < len(v.Array_shun)-1; i++ {
		if v.Array_shun[i+1]-v.Array_shun[i] == 3 {
			*mask |= mahjong.LIANLIU
			return
		}
	}
}

//老少副
//胡牌时，牌里花色相同的123、789的顺子各一副。
func IsLaoShaoFu(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_shun) < 2 {
		return
	}
	o := 0
	y := 0
	for _, m := range v.Array_shun {
		if o > 0 && y > 0 {
			*mask |= mahjong.LAOSHAOFU
			return
		}
		if m == 0 {
			y++
		} else if m == 8 {
			o++
		}
	}
}

//幺九刻
//胡牌时，牌里有序数为一、九的一副刻子(杠)或是字牌的一副刻子(杠)。
func IsYaoJiuKe(v *mahjong.MahjongCount, mask, noMask *int64) {
	var a []byte
	a = append(append(a, v.Array_ke...), v.Array_gang...)
	for _, m := range a {
		if m == 0 || m == 8 || (m > 26 && m < 31) {
			*mask |= mahjong.YAOJIUKE
			return
		}
	}
}

//明杠
//自己有暗刻，碰别人打出的一张相同的牌开杠:或自己抓进一张与碰的明刻相同
func IsMingGang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if len(v.Array_m_gang) > 0 {
		*mask |= mahjong.MINGGANG
	}
}

//边张
//单和123的3及789的7或1233和3、7789和7都为边张。手中有12345和3，56789和7不算边张。
//123 3 胡得那张牌只能是顺子的两边牌，两个相邻的顺子不能有连接）
func IsBianZhang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if v.HuIndex != 2 && v.HuIndex != 6 {
		return
	}
	for _, m := range v.Array_h_shun {
		if v.HuIndex == 2 {
			if m == 2 {
				return
			}
		} else if v.HuIndex == 6 && m+2 == 6 {
			return
		}
	}
	*mask |= mahjong.BIANZHANG
}

//坎张
//胡牌时，和2张牌之间的牌。4556和5也为坎张，手中有45567和6不算坎张。
func IsKanZhang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if v.HuIndex == 0 || v.HuIndex == 8 {
		return
	}
	//遍历手牌顺子，胡的那张牌必须在中间，
	for _, m := range v.Array_h_shun {
		if v.HuIndex == m || v.HuIndex == m+2 {
			return
		}
	}
	*mask |= mahjong.KANZHANG
}

//单钓将
//钓单张牌作将成和
func IsDanDiaoJiang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if v.HuIndex == v.Jiang {
		*mask |= mahjong.DANDIAOJIANG
	}
}

//自摸
//自己抓进牌成胡牌
func IsZiMo(v *mahjong.MahjongCount, mask, noMask *int64) {
	if v.Zimo {
		*mask |= mahjong.ZIMO
	}
}

//二五八将
//胡牌时，将牌是二万、五万、八万。
func IsErWuBaJiang(v *mahjong.MahjongCount, mask, noMask *int64) {
	if v.Jiang == 1 || v.Jiang == 4 || v.Jiang == 7 {
		*mask |= mahjong.ERWUBAJIANG
	}
}
给麻将游戏算番数
鹏鸽的专栏
04-27 4650
麻将游戏越来越受到大家喜爱，也在网络上盛行。本题目是给定一组已经和牌的麻将，编写一个函数计算这组麻将的番数。 为简化题目，假设麻将只有筒子和条子两种花型，能翻番的规则也只有以下三种，当一组牌中没有下述三种情况中的一种或多种， 则这组牌为0番，每种番数是加的关系，例如一组牌既有卡2条又有四归一，则番数为3番。 1.卡2条为一番，即有一局牌是 1条2条3条； 2.四归一为两番，即有4张一样的牌
国标麻将算番源代码
tingweiwang的专栏
08-02 4308
int myCount(int *in);int doit1(int *in,int count);int Hu(int pai[8],int jiang)Remain(int pai[38]]);int getHuKeZi(int pai[38],int huKeZi[5]);int getHuShunZi(int pai[38],int huShunZi[5]);int isDanDiaoji
二、计算麻将的番数
weixin_34082695的博客
03-13 827
同样是同学发过来的题目，做了下，代码如下 描述: 计算麻将的番数 麻将游戏越来越受到大家喜爱，也在网络上盛行。本题目是给定一组已经和牌的麻将，编写一个函数计算这组麻将的番数。为简化题目，假设麻将只有筒子和条子两种花型，能翻番的规则也只有以下三种，当一组牌中没有下述三种情况中的一种或多种，则这组牌为0番，每种番数是加的关系，例如一组牌既有卡2条又有四归一，则番数为3番。 1.卡2...
计算麻将的番数
J-SC-30
08-02 1209
计算麻将番数
麻将番数
谢语天
03-29 3346
麻将游戏越来越受到大家喜爱，也在网络上盛行。本题目是给定一组已经和牌的麻将，编写一个函数计算这组麻将的番数。为简化题目，假设麻将只有筒子和条子两种花型，能翻番的规则也只有以下三种，当一组牌中没有下述三种情况中的一种或多种，则这组牌为0番，每种番数是加的关系，例如一组牌既有卡2条又有四归一，则番数为3番。 1.卡2条为一番，即有一局牌是 1条2条3条； 2.四归一为两番，即有4张一样的牌(花色和
6003二人麻将代码
05-05
从标题“6003二人麻将代码”和描述“E二人麻将[原版]_机器人.rar”中，我们可以看出该项目至少包含了两个主要的组件：一个是游戏的主体代码库，另一个是AI机器人的实现。而“机器人”一词揭示了游戏的一个关键特性...
多人麻将源码 html5,新版大众麻将 H5版
weixin_39888268的博客
06-17 2907
第一章 概述第一条 为促进平台用户基于真实的交易作出公正、客观、真实的评价，进而为其他用户在购买服务的决策过程中提供有效参考，同时为服务者在经营店铺的过程中提供客户最真实的意见反馈提供参考，众创服平台根据《众创服平台服务协议》《众创服平台服务规则》等相关规定，制定本规则。第二条 本规则适用于在众创服平台完成交易的客户与服务者。第三条 众创服平台评价是指用户基于订单完结而产生的交易评价，即交易双方在...
​国标麻将(Chinese Standard Mahjong)是Botzone平台上的四人游戏。​
最新发布
强化学习曾小健
12-30 928
麻将在中国有着三千多年的历史，而后传播至世界各地，主要流行于亚洲，具有相当广泛的群众基础。中国国家体育总局于1998年7月制定了一套麻将规则，被称为国标麻将。国标麻将具有较强的制约性、趣味性、竞技性、观赏性。国标麻将是四人非完全信息游戏。牌山含有8张花牌，饼筒条的数牌108张，东南西北风牌16张，中发白箭牌12张，总计144张。开局时每名玩家各持有13张牌，称作“手牌”。四名玩家分坐在正方形桌子四边，按逆时针方向依次为东南西北家，以东家为庄家，其余家为闲家；
麻将胡牌递归算法(lua)
qq_34965242的博客
10-25 1741
麻将胡牌算法 运用递归思路，先找出两张一样的牌作将牌，然后在剩下的牌中找顺子和三个一样的牌，当剩余的牌数为0，则排定可以胡牌。目前只是四川麻将的赢牌番型，除去风牌的。可自行进行扩展。（万：11-19，筒：21-29，条31-39），直接可以下载使用。 mjwintable类： --赢牌倍率 gMJWinRate = { 1, 2, 4, 4, 4, 4, 8, 8, 8, 16, 16,...
AI麻将技术揭秘：麻将AlphaGo的Java代码实现
描述中提到的“麻将胡牌算法以及AI算法”，说明了该程序包含了两个主要部分：一是胡牌算法，二是AI算法。胡牌算法是指在麻将游戏中判断玩家是否可以胡牌（即获胜）的规则实现，是麻将游戏的核心规则之一。AI算法则是...
Python项目案例开发从入门到实战源代码第12章 两人麻将代码
01-03
Python项目案例开发从入门到实战源代码第12章 两人麻将代码
麻将算法（二）牌型转换以及接牌
weixin_40019413的博客
10-23 1587
public static int[] Cards =                 {                     0x01,  0x02,  0x03,  0x04,  0x05,  0x06,  0x07,  0x08,  0x09,//万                     0x01,  0x02,  0x03,  0x04,  0x05,  0x06,  0x07
大众麻将算番算法
gc_mike的博客
11-20 1万+
闲来无事，再把全套麻将算番代码贴出，供有缘人参考，该算法以标准的国标麻将81种番编写，并严格遵守5大算番规则，不重复原则，不拆移原则，不得相同的原则，就高不就低原则，套算一次原则。 &amp;lt;?php /** * Created by PhpStorm. * User: guochao&amp;lt;gc_mike@163.com&amp;gt; * Date: 18/10/10 * Time: 下午3:3...
游金麻将胡牌与算番
热门推荐
u010401391的专栏
03-26 2万+
 20170426添加： 基本规则： 龙岩新庄麻将是流行于福建地区的麻将玩法，只能碰和杠，不能吃牌，也不能吃胡。 每局游戏会开出一张金牌，金牌可以当任何牌使用。 分为半自摸和全自摸两种模式，半自摸系统默认游金5倍，全自摸只能游金4倍。 游戏规则： 一、定庄 第一局游戏开始，系统随机选定一玩家坐庄。庄家和牌或流局，下一局可以连庄，否则由庄家的下家坐庄。第一局为东风东局，如果下庄第二
麻将胡牌算法
LG_227的博客
04-05 3752
本文实现了一个胡牌算法，目前支持视频中讲解的三种番型，更多番型或者其它番型大家可以结合当地的麻将进行二次开发，项目中不仅有后台胡牌算法，而且还配备了前台页面，开发人员可以在前台中直接输入麻将对应的数据，操作十分方便。具体细节请观看视频讲解视频和demo下载地址：wisdomdd.cn视频中的源码可以点击【下载实例】进行下载, 环境配置: Eclipse+Maven+JDK1.7环境下载地址: ht...
华为2014机试样题及代码（四）
盗梦笔记
03-12 1371
好吧，这题我不会，因为我不会打麻将。桑不起。。还带这样的。。下面的是别人的做法，给大家看看。 题目： 麻将游戏越来越受到大家喜爱，也在网络上盛行。本题目是给定一组已经和牌的麻将，编写一个函数计算这组麻将的番数。为简化题目，假设麻将只有筒子和条子两种花型，能翻番的规则也只有以下三种，当一组牌中没有下述三种情况中的一种或多种，则这组牌为0番，每种番数是加的关系，例如一组牌既有卡2条又有四归一，则番数为
麻将游戏
weixin_33856370的博客
07-28 200
Description 　　在一种”麻将”游戏中，游戏是在一个有W＊H格子的矩形平板上进行的。每个格子可以放置一个麻将牌，也可以不放（如图所示）。玩家的目标是将平板上的所有可通过一条路径相连的两张相同的麻将牌，从平板上移去。最后如果能将所有牌移出平板，则算过关。　　这个游戏中的一个关键问题是：两张牌之间是否可以被一条路径所连接，该路径满足以下两个特性：...
lua——赢三张牌型处理相关算法（上）——牌值数据
九日王朝
05-18 4042
赢三张，我们东北管这个叫拖拉机。其他的几个名称是违规的。。 是一个简单粗暴的扑克牌（dubo）游戏。玩家每人三张牌，通过特定的牌型规则进行比大小。（押注什么的就不说了，具体详细规则请参考百度） 最近一直深陷在各种扑克玩法的牌型逻辑处理中，对比了一下，觉得赢三张应该算是比较简单的了，于是在这里写出一些牌型逻辑处理的算法。有些也适用于其他的扑克牌玩法。 注：语言为lua
python3 实现麻将胡牌问题
Wu_Jianing的博客
01-18 3010
题目描述： 清一色是麻将番种之一，指由一种花色的序数牌组成的和牌. 数字1-9，每个数字最多有4张牌 我们不考虑具体花色，我们只看数字组合。 刻子：三张一样的牌；如: 111, 222, 333, …, 999 顺子：三张连续的牌；如: 123, 234, 345, …, 789 对子：两张相同的牌；如: 11, 22, 33, …, 99 需要实现一个程序，判断给定牌，是否可以和牌（胡牌）。 和...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值