棋牌麻将 - 无癞子胡牌算法(第三版)

最新推荐文章于 2022-07-29 01:30:34 发布
最新推荐文章于 2022-07-29 01:30:34 发布
阅读量1.1k 收藏 1
点赞数
文章标签： 算法 棋牌 胡牌 麻将
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kunyus/article/details/78712843
版权

基础知识

本文涉及的所有名词均在博文中有说明： http://blog.csdn.net/kunyus/article/details/78644517

测试结果

测试环境:

MEM: 4 GB
CPU: Intel(R) Xeon(R) CPU E3-1231 v3 @ 3.40GHz
虚拟机软件: Oracle VM VirtualBox
测试机操作系统: Microsoft Windows 7 旗舰版(SP1)

测试结果

  • 带胡牌规则测试结果效率差本人猜测和 Golang 接口类型的实现方式有关.

  • 因为胡牌规则回调无逻辑直接返回 nil 时测试结果也在 120w 数量级.(模拟数据)

    无中间表纯拆牌(单一数据): 1s >= 700w
    带中间表完整算法(单一数据): 1s >= 450w
    带基础胡牌规则回调(单一数据): 1s >= 150w

    无中间表纯拆牌(模拟数据): 1s >= 450w
    带中间表完整算法(模拟数据): 1s >= 340w
    带基础胡牌规则回调(模拟数据): 1s >= 120w

核心思想

本算法分为两部分, 第一部分通过算法负责拆牌, 第二部分负责解析胡牌规则

  1. 去伪存真: 满足胡牌的部分, 要么是 {3*n}(不带将), 要么是 {3*n+2}(带将).

  2. 端本正源: 麻将牌胡牌(除特殊规则)和牌面没有直接关系, 只和数量以及所处位置(顺子)相关.

  3. 去粗取精: 麻将牌所有组合中, 只有顺子和其他牌有关联关系,且关系只存在于相连的两张牌中.

  4. 各司其职: 实现中胡牌规则和基础算法分离已保证算法的精简.此处实现通过事件触发方式隔离.

通用拆牌算法

生成中间表

  1. 将序数牌按花色以及牌个数进行归表并记录表中牌的总个数.

    此处用万举例, 其他花色结果一样:

    • 手牌 万: 1-9 各一张, 此时表内容应为: 111111111(9)
    • 手牌 万: 11 22 333 4 5 6 77 88, 此时表内容应为: 2231112200(14)

  2. 将字牌按牌个数进行归表并记录表中牌的总个数, 相邻牌用 0 隔开.

    如: 东风 南风 西风 北风 红中 发财 白板, 表内容: 1010101010101(7)

  3. 任意表中牌个数出现不满足 {3*n} 且不满足 {3*n+2} 的, 直接判定无法胡牌.

Golang 实现代码 :


// 0x01 - 0x09 - 筒
// 0x11 - 0x19 - 万
// 0x21 - 0x29 - 条
// 0x31 0x33 0x35 - 中发白
// 0x41 0x43 0x45 0x47 - 东南西北

func MarshalTiles(tiles []byte, filter MarshalFilter) (err error) {
    var mtables [5]struct {
        Count int
        Tiles [9]uint16
    }

    for _, tile := range tiles {
        group := uint16(tile) / 0x10

        if int(group+1) > len(mtables) {
            return errors.New("unrecognized type " + strconv.Itoa(int(group)) + " of tile")
        }

        index := uint16(tile) % 0x10 - 1

        if int(index) > (len(mtables[group].Tiles) - 1) {
            return errors.New("unrecognized tile " + strconv.Itoa(int(tile)))
        }

        mtables[group].Count++
        mtables[group].Tiles[index]++

        if mtables[group].Tiles[index] > 4 {
            return errors.New("abnormal number " + strconv.Itoa(int(mtables[group].Tiles[index])) + " of tile " + strconv.Itoa(int(tile)))
        }
    }

    for group, slice := range mtables {
        if 0 == slice.Count {
            continue
        }

        rest := slice.Count % 3 

        if 0 != rest && 2 != rest {
            return errors.New("slice length " + strconv.Itoa(int(slice.Count)) + " check does not pass")
        }


        if err := marshalSlice(group, slice.Tiles[:], filter); nil != err {
            return err
        }
    }

    if err := filter.OnComplete(); nil != err {
        return err
    }

    return nil
}

处理中间表

  1. 分别对生成的中间表进行正向遍历, 并分别进行 2 - 6 步处理.

  2. 当前位是否为 0, 为 0 直接跳到下一个继续处理.

  3. 当前值是否为 1 且表长度大于 3, 满足分别对当前值和后两个值减 1 , 出现负数无法胡牌.

  4. 当前位是否为 2, 满足将其视为刻子, 值改 0, 跳到下一个继续处理

  5. 当前位是否为 3 , 满足将值改为 1 跳到步骤 2 处理, 处理失败无法胡牌.

  6. 当前位是否为 4, 满足将值改为 1 跳到步骤 2 处理, 处理失败将值改为 1 跳到步骤 2 处理, 处理失败无法胡牌.

Golang 实现代码 :

type MeldType int

const (
    MeldPair MeldType = 1
    MeldTriplet MeldType = 2
    MeldSequence MeldType = 3
)

type MarshalFilter interface {
    OnComplete() (error)

    OnMeld(group int, index int, mtype MeldType) (error)
}

func marshalSlice(group int, slice []uint16, filter MarshalFilter) (error){
    sliceSize := len(slice)

    if nil == filter {
        tmp := make([]uint16, sliceSize)
        copy(tmp, slice)
        slice = tmp
    }

    for index, tile := range slice {
        for {
            if 0 == tile {
                break
            }

            var meldType MeldType

            switch(tile){
            case 0:
                break
            case 1:
                if (sliceSize - index) < 3 {
                    return errors.New("failed to remove sequence, slice length is not enough")
                } else if slice[index + 1] < 1 || slice[index + 2] < 1 {
                    return errors.New("failed to remove sequence, continuous tile does not exist")
                }

                tile = 0
                slice[index + 1]--
                slice[index + 2]--

                meldType = MeldSequence
            case 2:
                tile = 0
                meldType = MeldPair
            case 3:
                if ((sliceSize - index) > 3 && 4 == slice[index + 3]) { // 拆 3 拆 4 皆可时, 优先拆 4
                    tile = 0
                    meldType = MeldTriplet
                    break
                } 

                slice[index] = 1
                if err := marshalSlice(group, slice[index:], nil); nil == err { // 尝试拆 顺子
                    tile = 1
                    meldType = MeldPair
                } else {
                    tile = 0
                    meldType = MeldTriplet
                }

            case 4:
                slice[index] = 1
                if err := marshalSlice(group, slice[index:], nil); nil == err { // 尝试拆 顺子
                    tile = 1
                    meldType = MeldTriplet
                } else { // 拆成两个对子
                    tile = 2
                    meldType = MeldPair
                }
            }

            if nil == filter {
                continue
            }

            if err := filter.OnMeld(group, index, meldType); nil != err {
                return err
            }
        }

    }

    return nil
}

胡牌规则处理

拆牌算法在进行拆牌时会将所有数量为 2 的牌视为 对子, 这种情况在出现连续的 3 个 对子 时不满足基础胡法. 所以在基础胡法回调中会对 对子 进行特殊处理, 将连续的 3 个 对子 更新为顺子.

  • 此代码仅做 demo 使用, 里面有无用代码, 使用时请酌量删除.

Golang 实现代码 :


type BaseMarshalFilter struct {
    MeldCount [4]int
    Melds [4][5][9]int
}

func NewBaseMarshalFilter() (MarshalFilter){
    return &BaseMarshalFilter{
    }
}

func (b *BaseMarshalFilter) OnComplete() (error) {
    if b.MeldCount[MeldPair] != 1 {
        return errors.New("the number of eyes " + strconv.Itoa(b.MeldCount[MeldPair]) + " too much")
    }

    return nil
}

func (b *BaseMarshalFilter) OnMeld(group int, index int, mtype MeldType) (error) {
    if MeldPair == mtype && index >= 2 && b.MeldCount[MeldPair] >= 2 {
        if b.Melds[MeldPair][group][index - 1] >= 1 && b.Melds[MeldPair][group][index - 2] >= 1 {
            b.MeldCount[MeldPair] -= 2

            b.Melds[MeldPair][group][index-1]--
            b.Melds[MeldPair][group][index-2]--

            mtype = MeldSequence

            b.MeldCount[mtype]++
            b.Melds[mtype][group][index]++
        }
    }

    b.MeldCount[mtype]++
    b.Melds[mtype][group][index]++

    return nil
}

调用方式

        tiles := []byte{0x03, 0x03, 0x03, 0x03, 0x04, 0x05, 0x13, 0x13,  0x14,  0x15,  0x16, 0x27, 0x27, 0x27}
        if err := MarshalTiles(tiles, NewBaseMarshalFilter()); nil != err {
            print_tiles(tiles, 0, 0, err)
        }
kunyus
关注
麻将胡牌算法-癞子牌特别多（一）
灰猫
01-06 2608
麻将内最核心的算法，每一次出牌，摸牌都需要使用到。（仅个人想法，想要更快速度，建用把算出来的结果存储下来，通过查表法来使用） 1、计算前准备 /*癞子数量*/ protected byte laiNumber; /*癞子牌*/ protected List<Byte> laiPoker; /*手牌数量总计*/ protecte...
癞子麻将胡牌判断
chenjundnf的博客
08-07 545
var cardValue = [ 1,2,3,4,5,6,7,8,9, 11,12,13,14,15,16,17,18,19, 21,22,23,24,25,26,27,28,29, 31,41,51,61,71,81,91 ] /** 定扑 @param cards @param laizinum @returns {boolean} / function isPu(cards, laizi...
麻将癞子算法
02-20
麻将癞子算法
棋牌麻将 - 无癞子胡牌算法
kunyus的博客
11-29 1451
基础知识本文涉及的所有名词均在博文中有说明： http://blog.csdn.net/kunyus/article/details/78644517核心处理流程 去除杂念: 由于字牌中只只允许出现 对子 和 刻子, 所以单独处理字牌. 返璞归真: 万/筒/条牌等 序数牌 处理除了花色不同其他规则一致, 所以忽略 序数牌 花色进行处理. 分而治之: 序数牌中存在关系的牌必须是连续的, 不连续的牌之间
棋牌麻将 - 无癞子胡牌算法(优化)
kunyus的博客
11-30 941
基础知识本文涉及的所有名词均在博文中有说明： http://blog.csdn.net/kunyus/article/details/78644517核心思想 去伪存真: 满足胡牌的部分, 要么是 {3*n}(不带将), 要么是 {3*n+2}(带将). 端本正源: 麻将牌胡牌(除特殊规则)和牌面没有直接关系, 只和数量以及所处位置(顺子)相关. 去粗取精: 麻将牌所有组合中, 只有顺子和其他牌有关
棋牌AI常用算法和技巧
weixin_30853329的博客
03-19 606
写棋牌AI经常需要搜索所有非空真子集，举个例子 假设手牌{1,2,3,4}，那么我们可能需要搜索以下集合 {1,2,3,4} {1} {2} ...
麻将胡牌算法
不积跬步，无以至千里
07-29 9053
麻将胡牌算法。全国各地有很多种麻将玩法，胡牌也有很多种，但是对于胡牌而言，但是就手牌的组合规则而言，大体上满足几个大类。七对14张手牌，共有7个对子。十三幺万筒条的一九牌+东南西北中发白，再加上一张上述牌。3N+2N个顺子(ABC)或者刻子(AAA)，外加一对将。七对和十三幺是比较容易判断的牌型，而3N+2相对不容易判断，本章主要讲3N+2牌型如何判定。......
c++麻将胡牌算法，癞子胡牌算法
04-02
本项目主要探讨了如何使用C++语言实现麻将胡牌算法，包括普通胡牌规则以及特殊的“癞子”（也称为万能牌）胡牌规则。这里我们将深入解析这两种算法的核心原理。 首先，我们来看基础的麻将胡牌算法。麻将是一种四人...
麻将癞子胡牌算法
05-17
麻将癞子胡牌算法，效率超快。4个5个癞子都测试过，python语言写的。
golang版超高效带癞子麻将胡牌算法
10-23
golang版麻将胡牌算法，包含带癞子和不带癞子，将gui_index 设置为34 就是不带癞子的麻将胡牌算法，gui_index 设置为[0，34）就是带癞子的麻将胡牌算法
unity3d 麻将
04-26
untiy3d 开发的麻将，可以查看源码，红中麻将，转转麻将
golang 麻将胡牌快速算法，非常快
warrially的专栏
12-04 667
package main import ( "fmt" "io/ioutil" "math" "sort" "time" "github.com/yangtizi/go/sysutils" ) var mp map[int]bool func main() { mp = make(map[int]bool) dt := time.Now() for i := 1; i <= 9; i++ { jiangtou([]int{i, i}) } fmt.Println.
golang实现最简单的麻将胡牌算法（不包括牌型，有需求后续可以更新牌型计算）
万彬学习的博客
11-28 1264
话不多说，代码先给出来 文件名 mahjong.go 很多的实现方法，写的注释我觉得已经很详细了，多看下注释。 package main import ( "sort" "fmt" ) //牌类型 type CardType int const ( CardType_Unknown CardType = iota CardType_W CardType_T CardType_S ...
带癞子麻将查表判断胡牌高效率低内存算法
panshiqu的专栏
03-02 1万+
在我未查阅相关资料时，最初我有两种想法（本文只深入讨论第二种想法） * 像我当初做斗地主智能出牌机器人拆解手牌那样，拆解手牌后判定是否符合条件进而判定输赢。 * 组合出所有赢的手牌，构造 map，判定输赢只需查表即可，键值初步设想的是排序并拼接成的 string。
unity3D麻将开发的通用算法
嘿嘿
08-24 1万+
通常的3D麻将开发胡牌方式为满足N * ABC + M *DDD +ＥＥ 的形式，及存在一个对子(EE)，剩余牌均能组成顺子（ABC）或者刻子（DDD）。   很容易发现必须满足size%3 == 2的形式才可以去计算胡牌。 数据结构的选取： 开发3D麻将麻将有万、饼、条各九种，另外还有东西南北中，春夏秋冬。 种类不是很多，一个字节表示就可以了，前四位代表类型，后四位代表值，东西南北...
GO开发之路 麻将mahjong的基本实现
qq_43196500的博客
08-16 1138
基本情况 条、筒、万共108张 随机洗牌，每局开始，洗牌后牌序固定 按序摸牌、打牌、碰牌和胡牌 四方分别代号为0、1、2、3 1 洗牌 //洗牌 func (ms *mainStruct) xiPai() { //1 108个数随机生成 rand.Seed(time.Now().UnixNano()) ms.paiList = rand.Perm(108) } 2 初始发牌 //发牌 func (ms *mainStruct) faPai() { for i := 0; i < 4*13
Unity3D 通用麻将胡牌算法
TxNet
04-08 6938
声明: 算法并非原创 , 但是来源已经忘记了 , 当时考虑算法的时候看了比较多的麻将胡牌算法 , 想寻找自己比较容易理解的 , 找了几篇,所以算法的出处已然忘记,不过还是感谢下原创吧 .  　　算法理解之后就不难了 , 下面开始详细的阐述了. 1. 将麻将抽象为数字 　　数字 {01 ~ 09} 表示  {1 ~ 9} 筒 　　数字 {11 ~ 19} 表示  {1 ~ 9
癞子麻将胡牌以及听牌算法实现
热门推荐
skillart的专栏
10-24 3万+
最先实现的就是算法的实现。 需求：碰杠胡  ，不能吃 ，不能听 ，只能自摸胡，其中癞子可以做任意牌但是不能碰和杠。 写的时候还不会玩麻将，还是老板教的。^_^ 最麻烦的是胡牌算法。之前搜到的都是不包含癞子正常的胡牌，用的是%3余2，其中余数2就是余的将的意思。 但是有癞子就不能这么用了。只好自己写一个了。 一个有136张牌，万，饼，条，东西南北中发白34种牌。 有四个癞子是直接
Unity简单麻将胡牌算法
weixin_41765385的博客
10-24 1275
只考虑最简单的胡牌 一对将（对子）+4个坎(四个连顺子  123 456  或四个一样的111 222 或者两者之间的组合) // 将麻将抽象为数字 //数字 //{01 ~ 09} 表示 {1 ~ 9} 筒 //数字 {11 ~ 19} 表示 {1 ~ 9} 条 //数字 {21 ~ 29} 表示 {1 ~ 9} 万 //数字 {31 3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值