分享一个麻将听牌算法（带癞子）（Lua）

最新推荐文章于 2023-03-02 19:08:31 发布
最新推荐文章于 2023-03-02 19:08:31 发布
阅读量3.6k 收藏 4
点赞数 1
分类专栏： Lua
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a972114267/article/details/108300951
版权

算法已验证，目前没有发现问题，还有待优化，请指正（没有考虑东南西北中发白）；

M.CardTb = {
    {0,0,0,0,0,0,0,0,0}, --筒子
    {0,0,0,0,0,0,0,0,0}, --万字
    {0,0,0,0,0,0,0,0,0}, --条字
    {0}
}

---用于存放手牌个数，最后一个用来存放癞子，

首先创建一个table，用来存储手牌，我看到网上不少听牌算法用的都是一维数组，讲真我觉得一维数组有点眼花，所以用了二维数组。

M.Card = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,
        0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,
        0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,}

---听的牌

这个数组就是用来求那些牌可以胡牌的。

做完这些就可以来实现胡牌方法了

M.checkHu = function(CardTb,indexTb,value)
    local NewCardTb =  M.deepCopy(CardTb)
    local continue = true
    local Log = false

    local index1 = indexTb[1]
    local index2 = indexTb[2]
    if M.J258 then  --有些麻将对将牌有特殊需求（比如长沙麻将）
        if indexTb[2] ~= 2 and indexTb[2] ~= 5 and indexTb[2] ~= 8 then
            continue = false
            M.changeJiang(CardTb,index1,index2,value)
        end
    end
    if continue then
        if index1 == 3 and index2 == 5 and value == 0x02 then
            Log = true
        end
        if NewCardTb[index1][index2] == 0 then
            continue = false
            M.changeJiang(CardTb,index1,index2,value)
        else
            NewCardTb[index1][index2] = NewCardTb[index1][index2] - 1
            if NewCardTb[index1][index2]  > 0 then
                NewCardTb[index1][index2] = NewCardTb[index1][index2] - 1
                local result = M.check(NewCardTb,Log)
                if result then
                    table.insert(M.HuCardList,value)
                    if not M.HuType[tostring(value)] then
                        M.HuType[tostring(value)] = ''
                    end
                    local hutype = '平胡\n'
                    hutype = M.checkHuType(CardTb,hutype)
                    M.HuType[tostring(value)] = hutype
                    return true
                else
                    continue = false
                    M.changeJiang(CardTb,index1,index2,value)
                end
            else
                if M.LaiZi and NewCardTb[4][1] > 0 then
                    NewCardTb[4][1] = NewCardTb[4][1] - 1
                    local result = M.check(NewCardTb,Log)
                    if result then
                        table.insert(M.HuCardList,value)
                        table.insert(M.HuCardList,value)
                        if not M.HuType[tostring(value)] then
                            M.HuType[tostring(value)] = ''
                        end
                        local hutype = '平胡\n'
                        hutype = M.checkHuType(CardTb,hutype)
                        M.HuType[tostring(value)] = hutype
                        return true
                    else
                        continue = false
                        M.changeJiang(CardTb,index1,index2,value)
                    end
                else
                    continue = false
                    M.changeJiang(CardTb,index1,index2,value)
                end
            end
        end
    end
end

M.changeJiang = function(CardTb,index1,index2,value)
    index2 = index2 + 1
    if index2 == 10 then
       index1 = index1 + 1
       index2 = 1
    end
    if index1 < 4 then
        M.checkHu(CardTb,{index1,index2},value)
    end
end

看这段可能有点突兀，CardTb 这个参数是将手牌转化成前面说的二维数组，indexTb 是将牌位置的索引，value 是判断是否能胡的牌，这张牌已经添加进手牌了。M.chengeJiang 的主要作用就是在不能胡的情况下变更将牌，M.check是胡牌逻辑，

M.check = function(CardTb,Log)
    for k,valuetb in pairs(CardTb) do
        if k < 4 then
            for i = 1,7 do
                local value1 = valuetb[i]
                local value2 = valuetb[i + 1]
                local value3 = valuetb[i + 2]
                if value1 >= 3 then
                    valuetb[i] = valuetb[i] - 3
                    value1 = value1 - 3
                end
                if value2 >= 3 then
                    valuetb[i + 1] = valuetb[i + 1] - 3
                    value2 = value2 - 3
                end
                if value3 >= 3 then
                    valuetb[i + 2] = valuetb[i + 2] - 3
                    value3 = value3 - 3
                end
                if value1 + value2 + value3 == 6 then
                    valuetb[i] = 0
                    valuetb[i + 1] = 0
                    valuetb[i + 2] = 0
                    value3 = 0
                    value1 = 0
                    value2 = 0
                end
                if value1 + value2 + value3 == 5 and M.LaiZi and CardTb[4][1] > 0 then
                    value1 = 0
                    value2 = 0
                    value3 = 0
                    valuetb[i] = 0
                    valuetb[i + 1] = 0
                    valuetb[i + 2] = 0
                    CardTb[4][1] = CardTb[4][1] - 1
                end
                if value1 > 0 then
                    value1 = value1 -1
                    if value1 > 0 then
                        if M.LaiZi and CardTb[4][1] > 0 then
                            valuetb[i] = valuetb[i] - 2
                            CardTb[4][1] = CardTb[4][1] - 1
                        end
                    else
                        if value2 > 0 and value3 > 0 then
                            valuetb[i] = valuetb[i] - 1
                            valuetb[i + 1] = valuetb[i + 1] - 1
                            valuetb[i + 2] = valuetb[i + 2] - 1
                            value2 = value2 - 1
                            value3 = value3 - 1
                        elseif M.LaiZi and CardTb[4][1] > 0 then
                            if value2 + value3 > 0 then
                                valuetb[i] = valuetb[i] > 0 and valuetb[i] - 1 or 0
                                valuetb[i + 1] = valuetb[i + 1] > 0 and valuetb[i + 1] - 1 or 0
                                valuetb[i + 2] = valuetb[i + 2] > 0 and valuetb[i + 2] - 1 or 0
                                CardTb[4][1] = CardTb[4][1] - 1
                            else
                                if CardTb[4][1] >= 2 then
                                    valuetb[i] = valuetb[i] - 1
                                    CardTb[4][1] = CardTb[4][1] - 2
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    local count = 0
    for k,vTb in pairs(CardTb) do
        for k,v in pairs(vTb) do
            count = count + v
        end
    end
    return count == 0 and true or false
end

这个是优先把大于3张的做碰处理。然后是2张三连做吃处理（如果缺一张则用癞子补齐，有癞子的话），紧接者就是顺子，如果当前牌数为2的话，有癞子就用癞子补齐做碰处理

 

 

最后附上全部代码，


M = {}

M.CardTb = {
    {0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,0},
    {0}
}

M.Card = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,
        0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,
        0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,}

M.LaiZi = false
M.J258 = false

M.QingYiSe = false
M.JJH = false
M.PPH = false
M.QQR = false
M.QXD = false


M.HuCardList = {}
M.HuType = {}
M.TingCardList = {}


M.getTingCardLogic = function(handCardList, weaveCardList,gameType,liaZiTb,param1)
    M.TingCardList = {}
    local handCardCount = #handCardList
    local temp = {} --计算过可以的牌，添加进temp，后面就不会重复计算
    for i = 1,handCardCount do
        repeat
            local CardTb = M.deepCopy(handCardList)
            local value = CardTb[i]
            if M.isInTable(temp,value) then
                break
            end
            if not M.isInTable(liaZiTb,value) then
                CardTb[i] = nil
                M.getHuCardLogic(CardTb,weaveCardList,gameType,liaZiTb,param1)
                if #M.HuCardList > 0 then
                    if not M.TingCardList[tostring(value)] then
                        M.TingCardList[tostring(value)] = {}
                    end
                    M.TingCardList[tostring(value)]['hucard'] = M.HuCardList
                    M.TingCardList[tostring(value)]['hutype'] = M.HuType
                end
            end
            table.insert(temp,value)
        until true
    end
end

M.getHuCardLogic = function(handCardList, weaveCardList,gameType,liaZiTb,param1)

    M.LaiZi = false
    M.J258 = false
    M.QingYiSe = false
    M.JJH = false
    M.PPH = false
    M.QQR = false
    M.QXD = false

    M.handCardList = handCardList
    M.weaveCardList = weaveCardList
    M.gameType = gameType

    -------判断游戏是否有癞子，是否要2，5，8坐将--------------------------
    M.LaiZi = #liaZiTb > 0
    M.J258 = --根据具体游戏来判断是否需要2 5 8 坐将
    -------判断游戏是否有癞子，是否要2，5，8坐将--------------------------

    --------- 根据游戏类型判断大胡规则 ----------------------------------
    M.QingYiSe =  --根据具体游戏来判断是否可以胡此大胡

    M.QXD = --根据具体游戏来判断是否可以胡此大胡

    M.PPH = --根据具体游戏来判断是否可以胡此大胡

    M.JJH = --根据具体游戏来判断是否可以胡此大胡

    M.QQR = --根据具体游戏来判断是否可以胡此大胡
    --------- 根据游戏类型判断大胡规则 ----------------------------------

    local handCard = {}
    for i,v in pairs(handCardList) do
        table.insert(handCard,v)
    end
    M.HuCardList = {}
    M.HuType = {}
    for k,v in pairs(M.Card) do
        local cardlist = M.deepCopy(handCard)
        local needCheck = true
        table.insert(cardlist,v)
        local CardTb = M.convertToArr(cardlist,liaZiTb)
        M.J258 =  M.checkSpecialHu(CardTb)
        if M.isQiXiaoDui(CardTb) then
            needCheck = false
            table.insert(M.HuCardList,v)
            if not M.HuType[tostring(v)] then
                M.HuType[tostring(v)] = ''
            end
            local hutype = '平胡\n'
            hutype = M.checkHuType(CardTb,hutype)
            M.HuType[tostring(v)] = hutype
        end
        if needCheck and M.isJiangJiangHu(CardTb) then
            needCheck = false
            table.insert(M.HuCardList,v)
            if not M.HuType[tostring(v)] then
                M.HuType[tostring(v)] = ''
            end
            local hutype = '平胡\n'
            hutype = M.checkHuType(CardTb,hutype)
            M.HuType[tostring(v)] = hutype
        end
        if needCheck then
            M.checkHu(CardTb,{1,1},v)
        end
    end
    M.removeRepeated(M.HuCardList)
end

M.checkSpecialHu = function(CardTb)  --检查是否符合大胡规则，不确定是否胡牌,作用于是否需要2，5，8坐将
    if M.QingYiSe then
        if M.isQingYiSe(CardTb) then
            return false
        end
    end
    if M.PPH then
        if M.isPengPengHu(CardTb) then
            return false
        end
    end
    if M.QQR then
        if M.isQuanQiuRen(CardTb) then
            return false
        end
    end
    return true
end

M.checkHuType = function(CardTb,hutype)
    if M.QingYiSe then
        if M.isQingYiSe(CardTb) then
            hutype = hutype .. '清一色\n'
        end
    end
    if M.QXD then
        if M.isQiXiaoDui(CardTb) then
            hutype = hutype .. '七小对\n'
        end
    end
    if M.PPH then
        if M.isPengPengHu(CardTb) then
            hutype = hutype .. '碰碰胡\n'
        end
    end
    if M.JJH then
        if M.isJiangJiangHu(CardTb) then
            hutype = hutype .. '将将胡\n'
        end
    end
    if M.QQR then
        if M.isQuanQiuRen(CardTb) then
            hutype = hutype .. '全求人\n'
        end
    end

    return hutype
end

M.checkHu = function(CardTb,indexTb,value)
    local NewCardTb =  M.deepCopy(CardTb)
    local continue = true
    local Log = false

    local index1 = indexTb[1]
    local index2 = indexTb[2]
    if M.J258 then
        if indexTb[2] ~= 2 and indexTb[2] ~= 5 and indexTb[2] ~= 8 then
            continue = false
            M.changeJiang(CardTb,index1,index2,value)
        end
    end
    if continue then
        if index1 == 3 and index2 == 5 and value == 0x02 then
            Log = true
        end
        if NewCardTb[index1][index2] == 0 then
            continue = false
            M.changeJiang(CardTb,index1,index2,value)
        else
            NewCardTb[index1][index2] = NewCardTb[index1][index2] - 1
            if NewCardTb[index1][index2]  > 0 then
                NewCardTb[index1][index2] = NewCardTb[index1][index2] - 1
                local result = M.check(NewCardTb,Log)
                if result then
                    -- logError('xx : '..Json.encode(CardTb))
                    table.insert(M.HuCardList,value)
                    if not M.HuType[tostring(value)] then
                        M.HuType[tostring(value)] = ''
                    end
                    local hutype = '平胡\n'
                    hutype = M.checkHuType(CardTb,hutype)
                    M.HuType[tostring(value)] = hutype
                    return true
                else
                    continue = false
                    M.changeJiang(CardTb,index1,index2,value)
                end
            else
                if M.LaiZi and NewCardTb[4][1] > 0 then
                    NewCardTb[4][1] = NewCardTb[4][1] - 1
                    local result = M.check(NewCardTb,Log)
                    if result then
                        -- logError('bb : '..Json.encode(CardTb))
                        table.insert(M.HuCardList,value)
                        table.insert(M.HuCardList,value)
                        if not M.HuType[tostring(value)] then
                            M.HuType[tostring(value)] = ''
                        end
                        local hutype = '平胡\n'
                        hutype = M.checkHuType(CardTb,hutype)
                        M.HuType[tostring(value)] = hutype
                        return true
                    else
                        continue = false
                        M.changeJiang(CardTb,index1,index2,value)
                    end
                else
                    continue = false
                    M.changeJiang(CardTb,index1,index2,value)
                end
            end
        end
    end
end

M.changeJiang = function(CardTb,index1,index2,value)
    index2 = index2 + 1
    if index2 == 10 then
       index1 = index1 + 1
       index2 = 1
    end
    if index1 < 4 then
        M.checkHu(CardTb,{index1,index2},value)
    end
end

M.check = function(CardTb,Log)
    for k,valuetb in pairs(CardTb) do
        if k < 4 then
            for i = 1,7 do
                local value1 = valuetb[i]
                local value2 = valuetb[i + 1]
                local value3 = valuetb[i + 2]
                if value1 >= 3 then
                    valuetb[i] = valuetb[i] - 3
                    value1 = value1 - 3
                end
                if value2 >= 3 then
                    valuetb[i + 1] = valuetb[i + 1] - 3
                    value2 = value2 - 3
                end
                if value3 >= 3 then
                    valuetb[i + 2] = valuetb[i + 2] - 3
                    value3 = value3 - 3
                end
                if value1 + value2 + value3 == 6 then
                    valuetb[i] = 0
                    valuetb[i + 1] = 0
                    valuetb[i + 2] = 0
                    value3 = 0
                    value1 = 0
                    value2 = 0
                end
                if value1 + value2 + value3 == 5 and M.LaiZi and CardTb[4][1] > 0 then
                    value1 = 0
                    value2 = 0
                    value3 = 0
                    valuetb[i] = 0
                    valuetb[i + 1] = 0
                    valuetb[i + 2] = 0
                    CardTb[4][1] = CardTb[4][1] - 1
                end
                if value1 > 0 then
                    value1 = value1 -1
                    if value1 > 0 then
                        if M.LaiZi and CardTb[4][1] > 0 then
                            valuetb[i] = valuetb[i] - 2
                            CardTb[4][1] = CardTb[4][1] - 1
                        end
                    else
                        if value2 > 0 and value3 > 0 then
                            valuetb[i] = valuetb[i] - 1
                            valuetb[i + 1] = valuetb[i + 1] - 1
                            valuetb[i + 2] = valuetb[i + 2] - 1
                            value2 = value2 - 1
                            value3 = value3 - 1
                        elseif M.LaiZi and CardTb[4][1] > 0 then
                            if value2 + value3 > 0 then
                                valuetb[i] = valuetb[i] > 0 and valuetb[i] - 1 or 0
                                valuetb[i + 1] = valuetb[i + 1] > 0 and valuetb[i + 1] - 1 or 0
                                valuetb[i + 2] = valuetb[i + 2] > 0 and valuetb[i + 2] - 1 or 0
                                CardTb[4][1] = CardTb[4][1] - 1
                            else
                                if CardTb[4][1] >= 2 then
                                    valuetb[i] = valuetb[i] - 1
                                    CardTb[4][1] = CardTb[4][1] - 2
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    local count = 0
    for k,vTb in pairs(CardTb) do
        for k,v in pairs(vTb) do
            count = count + v
        end
    end
    return count == 0 and true or false
end



M.convertToArr = function(handCardList,liaZiTb)
    local CardTb = M.deepCopy(M.CardTb)
    for k,value in ipairs(handCardList) do
        if M.isInTable(liaZiTb,value) then
            CardTb[4][1] = CardTb[4][1] + 1
        else
            local suit = math.modf(value/16) + 1
            CardTb[suit][math.fmod(value, 16)] = CardTb[suit][math.fmod(value, 16)] + 1
        end
    end
    return CardTb
end

M.isQingYiSe = function(CardTb)
    local AllCardTb = M.deepCopy(CardTb)
    for k,value in ipairs(M.weaveCardList) do
        local suit = math.modf(value/16) + 1
        AllCardTb[suit][math.fmod(value, 16)] = AllCardTb[suit][math.fmod(value, 16)] + 1
    end
    for k,valuetb in pairs(AllCardTb) do
        local count = 0
        for k,value in pairs(valuetb) do
            count = count + value
        end
        count = count + AllCardTb[4][1]
        if count >= 14 then
            return true
        end
    end
    return false
end

M.isQiXiaoDui = function(CardTb)
    local newCardTb = M.deepCopy(CardTb)
    local count = 0
    for k,valueTb in pairs(newCardTb) do
        if k <= 3 then
            for k,v in pairs(valueTb) do
                if newCardTb[4][1] > 0 and v%2 ~= 0 then
                    newCardTb[4][1] = newCardTb[4][1] - 1
                else
                    if v%2 ~= 0 then
                        return false
                    end
                end

            end
        end
    end
    for k,v1 in pairs(CardTb) do
        for k,v in pairs(v1) do
            count = count + v
        end
    end
    if count ~= 14 then
        return false
    end
    return true
end

M.isJiangJiangHu = function(CardTb)
    local count = 0
    for k,valueTb in pairs(CardTb) do
        for k1,v in pairs(valueTb) do
            if v > 0 and k1 ~= 2 and k1 ~= 5 and k1 ~= 8 then
                return false
            end
            count = count + v
        end
    end
    if count ~= 14 then
        return false
    end
    return true
end

M.isQuanQiuRen = function(CardTb)
    local count = 0
    for k,valueTb in pairs(CardTb) do
        for k1,v in pairs(valueTb) do
            count = count + v
        end
    end
    if count ~= 2 then
        return false
    end
    return true
end

M.isPengPengHu = function(CardTb)
    local AllCardTb = M.deepCopy(M.CardTb)
    for k,value in ipairs(M.weaveCardList) do
        local suit = math.modf(value/16) + 1
        AllCardTb[suit][math.fmod(value, 16)] = AllCardTb[suit][math.fmod(value, 16)] + 1
    end
    for k,valueTb in pairs(AllCardTb) do
        for k,v in pairs(valueTb) do
            if v ~= 0 and v >= 3 then
                return false
            end
        end
    end
    local count = 0
    local pengcount = 0
    for k,valueTb in pairs(CardTb) do
        for k,v in pairs(valueTb) do
            count = count + v
            if v == 3 then
                pengcount = pengcount + 1
            end
        end
    end
    if pengcount*3 + 2 ~= count then
        return false
    end
    return true
end

M.isInTable = function(tb,value)
    for k,v in ipairs(tb) do
        if v == value then
            return true
        end
    end
    return false
end

M.deepCopy = function (object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object
        elseif lookup_table[object] then

            return lookup_table[object]
        end  -- if
        local new_table = {}
        lookup_table[object] = new_table


        for index, value in pairs(object) do
            new_table[_copy(index)] = _copy(value)
        end
        return setmetatable(new_table, getmetatable(object))
    end
    return _copy(object)
end

M.removeRepeated = function(a)
    for k,v in pairs(a) do
        local count=0
        for j in pairs(a)do count=count+1 end
        for i=k+1,count do
            if v==a[i] then
                table.remove(a,i)
            end
        end
    end
end

return M

最后说明一下，外部用的方法 M.getTingCardLogic 可以用来计算打出那些牌可以听那些牌，M.getHuCardLogic 计算可以听那些牌。 M.HuCardList  M.HuType 在使用 M.getHuCardLogic 会用到来存储胡牌信息 ，M.TingCardList 在使用M.getTingCardLogic用来存储听牌信息，两个方法参数一样，前三个参数就不解释了。liaZiTb 是有癞子玩法的时候把那些牌是癞子放到数组中。param1 大多数情况是没有用的，有玩法是选中大胡玩法才可以胡大胡，而大胡是不需要坐将的，所以param1根据自己的实际需要做处理

底层学渣
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
麻将清一色判和
weixin_44420710的博客
03-01 2947
麻将清一色判和//C语言题目示例 题目 是这样的，雀儿最近迷上了打麻将。但是她不知道怎么才能清一色和牌。麻将的清一色和牌规则是：雀儿手里有13张同一类型的牌（万、筒或索中的一种，从1到9），现在要再获得一张牌（共计14张）使牌型满足mAAA+nABC+DD（AAA表示三张相同的牌，ABC表示三张连续升序的牌，DD表示两张相同的牌，m+n=4）。现在请你帮助雀儿判断雀儿手中的牌能不能在再获得一张牌后...
麻将听牌的算法(java)
天堂来客
09-06 1万+
   近来正在做麻将游戏，写了个判断听牌的算法（暂且称其为算法），和大家分享一下，算法还没通过全面的验证，可能会遗漏某些情况。（我不太会打麻将阿）其中判断和牌算法的程序代码是网上找的，是听牌算法的基石。在这感谢这位仁兄了。1、在介绍算法之前，先说说我的牌值顺序： 0-8  : 1-9万 9-17 : 1-9筒 18-26: 1-9条 27-30: 东南西北风 31-33: 中发白 无花2、MaJi
麻将癞子胡牌算法
05-17
麻将癞子胡牌算法，效率超快。4个5个癞子都测试过，python语言写的。
麻将清一色胡牌算法（C版）
07-03
14张麻将的清一色胡牌算法，VC编译和测试通过......
麻将胡牌算法（遍历+剪枝）
weixin_44592761的博客
03-02 1万+
这个算法采用以遍历为基础的方法对胡牌进行搜索，并加入了一定的剪枝策略。没有对算法复杂度和运行时间进行测试，但整体运行速度基本可观，基本剪去了大部分无用的搜索。这个算法是部署在我的个人网站上的（因服务器资源极其有限（0_0），所以写的这个服务主要是给亲友使用的，需要授权会员码成为会员才能够体验哦，如果有童鞋想体验下的话可以在我的个人网站上找到我的联系方式要下会员码，所以我使用TypeScript语言编写的，用JavaScript语言的童鞋可以稍加修改后服用。
计算器1.0
rosetyler的博客
10-01 673
数据结构让我们相遇 计算器1.0正式上线： define.h: #include<stdlib.h> #include<stdio.h> typedef char datatype; #define maxsize 64 typedef struct { datatype data[maxsize]; int top; }seqstack; void SetNULL(seqstack *s) { s->top=-1; } int Empty(seqstack *s)
c++麻将胡牌算法，癞子胡牌算法
04-02
在C++中，我们可以创建一个麻将牌类，存储牌的类型（万、条、筒）和数值，然后定义一个玩家类，包含手牌数组和胡牌条件。胡牌的基本算法通常采用回溯法，这是一种试探性的解决问题的方法，当发现无法达成目标时，会...
麻将算法源码（任意癞子）
02-10
分享一个麻将胡牌算法，支持多癞子，自己对麻将胡牌的理解写的一套快速识别胡牌逻辑，核心逻辑500行代码，仅对同条万进行处理，字花牌不包含在内，易理解，1M次随机胡牌牌型大概3秒左右。原创分享，我的算法也许可以...
麻将癞子算法
02-20
麻将癞子算法
golang版超高效带癞子麻将胡牌算法
10-23
golang版麻将胡牌算法，包含带癞子和不带癞子，将gui_index 设置为34 就是不带癞子的麻将胡牌算法，gui_index 设置为[0，34）就是带癞子的麻将胡牌算法
麻将胡牌表_lua_列表_majiang_计算式_算法_
09-29
一个麻将胡牌表的计算方法，列出了从3张麻将到15张麻将的全部的胡牌组合，采用了LUA简单编程，易学易会。
vb麻将分析器，用于分析13张麻将听什么些牌
11-18
编写麻将软件的副产品，用于分析13张麻将听什么些牌
麻将分数计算记录系统含数据库和演示数据
10-12
经过多次自己使用反馈修改。现可用于打麻将时的分数记录和自动计算，省去每局发红包的时间。上传既能使用，最重要简单实用。
C++实现麻将基本听牌胡牌的算法
sdghchj的博客
08-03 1万+
c++实现麻将的基本胡牌与听牌算法，包括小七对和十三幺牌型。
癞子麻将胡牌以及听牌算法实现
热门推荐
skillart的专栏
10-24 3万+
最先实现的就是算法的实现。 需求：碰杠胡  ，不能吃 ，不能听 ，只能自摸胡，其中癞子可以做任意牌但是不能碰和杠。 写的时候还不会玩麻将，还是老板教的。^_^ 最麻烦的是胡牌算法。之前搜到的都是不包含癞子正常的胡牌，用的是%3余2，其中余数2就是余的将的意思。 但是有癞子就不能这么用了。只好自己写一个了。 一个有136张牌，万，饼，条，东西南北中发白34种牌。 有四个癞子是直接
胡牌算法 lua 速度比较稳定2
qq_36248022的博客
10-02 260
--[[ file:mahjongArithmetic.lua desc:胡牌算法 auth:CarolLuo 之前那个版本速度不太稳定 这个版本 总体速度要好一些 也没考虑癞子，这个版本性能主要卡在mappingKey 组合字符串key 消耗比较大 如果能改成数字那么性能可以提升一倍 多（目前没有思路） 1，目前我是提前把生成的隐射放在另外一个文件加载 因为自己生成需要2~3秒的时间 提前生成 require 速度很快 是毫秒级别 2...
华为笔试算法：清一色胡牌问题（java）
u014799309的博客
03-03 3482
题目描述： 清一色是麻将番种之一，指由一种花色的序数牌组成的和牌。数字1-9，每个数字最多有4张牌。我们不考虑具体花色，我们只看数字组合。 刻子：三张一样的牌；如: 111, 222, 333, ..., 999 顺子：三张连续的牌；如: 123, 234, 345, ..., 789 对子：两张相同的牌；如: 11, 22, 33, ..., 99 需要实现一个程序，判断给定牌，是否可以和牌（胡...
棋牌游戏算法——麻将系列总结
从事棋.牌行业五年，参与项目从0到1的过程，担任过海外项目的技术负责人，对业务中的俱乐部设计，玩法设计，架构，算法，数据有深刻的理解。
06-21 6637
麻将的胡牌算法，各种不同的麻将类型分析，总结。麻将的查表法，回溯法。
麻将听牌，胡牌算法
微笑流浪
02-19 3020
最近在研究麻将的算法，自己手写了一份记录一下以后查阅 只实现了听牌，翻数计算还没有做处理，后期在写 麻将万1-9 条11-19 筒21-29 核心：枚举出对子，然后找出刻子，找出顺子 直接上代码： public static void main(String[] args) { List&lt;Integer&gt; list = new ArrayList&lt;...
在python中如何定义斗地主癞子牌
最新发布
05-22
在斗地主中，癞子牌可以代替任何牌来组成牌型，因此需要在定义牌时将癞子牌也加入到牌的列表中。以下是一个简单的示例代码： ...然后将癞子牌和普通牌的点数与花色分别组合起来，得到一个完整的牌组。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值