十三水获取所有排列组合算法

朱雀 2022-05-19 08:20 312阅读 0赞

# 十三水组合算法 #

公司内部的算一次要100多毫秒一次，于是自己实现了一个十三水算法，算一次只要0.6-0.8ms，以下是代码

local ffi = require('ffi');
    
    --牌型
    local CT_SINGLE	 					=   1								--单牌类型 乌龙
    local CT_ONE_DOUBLE					=   2								--只有一对
    local CT_FIVE_TWO_DOUBLE			=	3								--两对牌型
    local CT_THREE			            =	4								--三张牌型
    local CT_FIVE_MIXED_FLUSH_NO_A		=   5								--顺子
    local CT_FIVE_FLUSH					=   6								--同花五牌
    local CT_FIVE_THREE_DEOUBLE			=   7 								--三条一对
    local CT_FIVE_FOUR_ONE				=   8								--四带一张
    local CT_FIVE_STRAIGHT_FLUSH_NO_A	=	9								--同花顺
    local CT_FIVE_FIVE_ONE              =  10                               --5同
    
    
    --是否只比较点数
    -- true  只比较牌大小,不比较花色
    -- false 先比较牌大小,再比较花色
    local bOnlyCompareNumber = false;    
    
    --支持5人以上的牌型比较
    -- 1 -新版本 0-老版本(4人)
    local bFuncVersion =  1;
    
    local function num2hex(arr)
        local newarr = {};
        
        for i,v in ipairs(arr) do
            table.insert(newarr, string.format("0x%x", v));
        end
        
        return newarr;
    end
    
    --[[ 按十三水的规则比较1-13的大小
        return 1: a > b
        return 0: a == b
        return -1: a < b
    ]]
    local function singleCardCompare(a, b)
        if a ~= b and (a ~= 1 and b ~=1) then
            if a > b then
                return 1;
            else
                return -1;
            end
        elseif a ~= b and (a == 1 or b == 1) then
            if a == 1 then
                return 1;
            else
                return -1;
            end
        elseif a == b then
            return 0;
        end
    end
    
    --[[ 比较牌面值
        return false: a >= b
        return true:  a < b
    ]]
    local function singleCardCompareValSmaller(a, b)
        local res = singleCardCompare(a%0x10, b%0x10);
        if res >= 0 then
            return false
        else
            return true;
        end
    end
    
    -- 拷贝数据
    local function copy_array(arr)
        local newarr = {};
        for i,v in ipairs(arr) do
            if type(v) == type({}) and #v ~= 0 then
                table.insert(newarr, copy_array(v));
            else
                table.insert(newarr, v);
            end
        end
        return newarr;
    end
    
    -- 合并数据
    local function merge_array(a1, a2)
        local new = {};
        for i,v in ipairs(a1 or {}) do
            table.insert(new, v);
        end
        for i,v in ipairs(a2 or {}) do
            table.insert(new, v);
        end
        return new;
    end
    
    -- 分隔数组
    local function split_array(arr, st, en)
        local newarr = {};
        en = en or #arr;
        for i = en, st, -1 do
            table.insert(newarr, 1, arr[i]);
            table.remove(arr, i);
        end
        return newarr, arr;
    end
    
    -- 根据位置移除值
    local function rm_arr_by_pos(arr, pos_arr)
        local rm_arr = {};
        table.sort(pos_arr, function (a1,a2) return a1 > a2; end);
        for i,pos in ipairs(pos_arr) do
            table.insert(rm_arr, arr[pos]);
            table.remove(arr, pos);
        end
        return rm_arr;
    end
    
    -- 根据位置获取值
    local function get_arr_by_pos(arr, pos_arr)
        local new = {};
        for i,pos in ipairs(pos_arr) do
            table.insert(new, arr[pos]);
        end
        return new;
    end
    
    -- 获取花色的桶
    -- 输入:get_hua_bucket({0x1, 0x02, 0x11, 0x21, 0x31, 0x32})
    -- 输出:{[0] = {1, 2}, [0x10] = {3}, [0x20] = {4}, [0x30] = {5, 6}}
    local function get_hua_bucket(cards)
        local bucket = {};
        for i = 1, 4, 1 do table.insert(bucket, {}); end
            
        for i = 1, #cards, 1 do
            local val = math.floor((cards[i]+0x10)/0x10);
            table.insert(bucket[val], i);
        end
        return bucket;
    end
    
    -- 根据位置获取值，再根据值获取位置，并形成桶
    -- 例:get_pos_bucket({0x1, 0x11, 0x21, 0x33, 0x23, 0x15, 0x16}, {1,2,3,4,5})
    -- 输出{[1] = {1,2,3}, [3] = {4,5}}
    local function get_ppos_bucket(cards, pos_arr)
        local bucket = {};
        
        for i = 1, 13, 1 do table.insert(bucket, {}); end
    
        for i = 1, #pos_arr, 1 do
            local val = cards[pos_arr[i]]%0x10;
            table.insert(bucket[val], pos_arr[i]);
        end
        return bucket;
    end
    
    -- 获取同值的位置，并形成桶
    -- 例:get_pos_bucket({0x1, 0x11, 0x21, 0x33, 0x23}, 5), 输出{[1] = {1,2,3}, [3] = {4,5}}
    local function get_pos_bucket(cards, length)
        local bucket = {};
        
        for i = 1, 13, 1 do table.insert(bucket, {}); end
    
        for i = 1, #cards, 1 do
            local val = cards[i]%0x10;
            table.insert(bucket[val], i);
        end
        return bucket;
    end
    
    -- CN/M组合获取
    -- 例:make_ranks({1,2,3},2), 输出{
       {1,2}, {2,3}, {1,3}}
    -- 例:make_ranks({1,2,3},1), 输出{
       {1}, {2}, {3}}
    local function make_ranks(cards, num)
        if #cards == num then
            return {cards};
        end
        local ranks = {};
        local count = #cards - num + 1;
        for i = 1, count, 1 do
            if num > 1 then
                local newcards = copy_array(cards);
                local rmcards, leftcards = split_array(newcards, 1, i);
                local child_ranks = make_ranks(leftcards, num-1);
                for ii,vv in ipairs(child_ranks) do
                    table.insert(vv, 1, cards[i])
                    table.insert(ranks, vv);
                end
                
            elseif num == 1 then
                local rank = {cards[i]};
                table.insert(ranks, rank);
            end
        end
        return ranks;
    end
    
    -- 判断是否同花
    local function isTHua(cards, pos_arr)
        local newcards = get_arr_by_pos(cards, pos_arr);
    
        local bucket = get_hua_bucket(newcards);
        
        for i,v in ipairs(bucket) do
            if #v >= 5 then return true; end
        end
        return false;
    end
    
    -- 判断是否是顺子
    local function isShunZi(cards, pos_arr)
        local newcards = get_arr_by_pos(cards, pos_arr);
        local bucket = get_pos_bucket(newcards);
        
        local cnt = 0;
        
        for i,v in ipairs(bucket) do
            if #v ~= 0 then
                cnt = cnt + 1;
                if cnt >= 5 then return true; end
            else
                cnt = 0;
            end
        end
        -- 最后还有4次连续说明是: 10,J,Q,K
        if cnt == 4 then
            -- 判断A存在则是顺子
            if #bucket[1] ~= 0 then
                return true;
            end
        end
        return false;
    end
    
    -- 识别5张，8人场，两副牌会有5张相同
    local function regWTongFunc(cards)
        local bucket = get_pos_bucket(cards);
        
        local wtong_arr = {};
        for i,v in ipairs(bucket) do
            if #v > 5 then
                local wtongs = make_ranks(cards, 5);
                for ii,vv in ipairs(wtong_arr) do
                    table.insert(wtong_arr, vv);
                end
            elseif #v == 5 then
                table.insert(wtong_arr, v);
            end
        end
        
        local ranks = {};
        for i,wtong in ipairs(wtong_arr) do
            local newcards = copy_array(cards);
            local rmcards = rm_arr_by_pos(newcards, wtong);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
    
        return ranks;
    end
    
    -- 识别同花顺，存在大于同花顺则失败
    local function regTHShunFunc(cards)
        local bucket_hua = get_hua_bucket(cards);
        local thshun_arr = {};
        for i,v in ipairs(bucket_hua) do
            if #v >=5 then
                local bucket_pos = get_ppos_bucket(cards, v);
                local thshun_pos = {};
    
                for ii,vv in ipairs(bucket_pos) do
                    if #vv ~= 0 then
                        table.insert(thshun_pos, vv[1]);
                        if #thshun_pos == 5 then
                            table.insert(thshun_arr, copy_array(thshun_pos));
                            table.remove(thshun_pos, 1);
                        end
                    else
                        thshun_pos = {};
                    end
                end
                
                -- 长度等于4说明有 10,J,Q,K
                if #thshun_pos == 4 then
                    -- 如果有A 则是同花顺
                    if #bucket_pos[1] ~= 0 then
                        table.insert(thshun_pos, bucket_pos[1][1]);
                        table.insert(thshun_arr, thshun_pos);
                    end
                end
            end
        end
        
        local ranks = {};
        for i,thshun in ipairs(thshun_arr) do
            local newcards = copy_array(cards);
            local rmcards = rm_arr_by_pos(newcards, thshun);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
        
        return ranks;
    end
    
    -- 识别四张，铁支
    local function regTZhiFunc(cards)
        local bucket = get_pos_bucket(cards);    
        local tzhi_arr = {};
        local wulong = {};
        
        for i,v in ipairs(bucket) do
            if #v > 4 then
                local tzhis = make_ranks(v, 4);
                for i,v in ipairs(tzhis) do
                    table.insert(tzhi_arr, v);
                end
            elseif #v == 4 then
                table.insert(tzhi_arr, v);
            end
        end
        
        local ranks = {};
        for i,tzhi in ipairs(tzhi_arr) do
            local newcards = copy_array(cards);
            local rmcards = rm_arr_by_pos(newcards, tzhi);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
        
        return ranks;
    end
    
    -- 识别葫芦，三带二
    local function regHLuFunc(cards)
        local bucket = get_pos_bucket(cards);
        
        local san_arr = {};
        local same_arr = {};
        local dui_arr = {};
        local tzhis = {};
    
        for i,v in ipairs(bucket) do
            if #v > 4 then
                return {};
            elseif #v == 4 then
                tzhis[i] = true;
                local sans = make_ranks(v, 3);
                for i,v in ipairs(sans) do
                    sans.val = i;
                    table.insert(san_arr, v);
                end
            elseif #v == 3 then
                v.val = i;
                table.insert(san_arr, v);
            elseif #v == 2 then
                table.insert(dui_arr, v);
            end
        end
        
        if #san_arr == 0 or #san_arr == 1 and #dui_arr == 0 then
            return {};
        end
        
        local ranks = {};
        for i,san in ipairs(san_arr) do
            for ii,dui in ipairs(dui_arr) do
                local newcards = copy_array(cards);
                local hlu = merge_array(dui, san);
                local rmcards = rm_arr_by_pos(newcards, hlu);
                table.insert(ranks, {cards = rmcards, next = newcards});
            end
            
            for ii,duis in ipairs(san_arr) do
                -- 判断三张的值相等不相等
                if duis.val ~= san.val and tzhis[duis.val] == nil then
                    local dui_arr = make_ranks(duis, 2);
                    for iii,dui in ipairs(dui_arr) do
                        local newcards = copy_array(cards);
                        local hlu = merge_array(dui, san);
                        local rmcards = rm_arr_by_pos(newcards, hlu);
                        table.insert(ranks, {cards = rmcards, next = newcards});
                    end
                end
            end
        end
        
        return ranks;
    end
    
    -- 识别同花，存在大于同花则失败
    local function regTHuaFunc(cards)
        -- 只要同花, 同花顺都不要
        local bucket = get_hua_bucket(cards);
        local ranks = {};
        
        for i,v in ipairs(bucket) do
            if #v >= 5 then
                -- 存在同花
                local thua_ranks = make_ranks(v, 5);
                for ii,thua in ipairs(thua_ranks) do
                    if not isShunZi(cards, thua) then
                        local newcards = copy_array(cards);
                        local rmcards = rm_arr_by_pos(newcards, thua);
                        table.insert(ranks, {cards = rmcards, next = newcards});
                    end
                end
            end
        end
        return ranks;
    end
    
    -- 识别顺子，存在大于顺子则失败
    local function regShZiFunc(cards)
        local bucket = get_pos_bucket(cards)
    
        local cont_pos = {};
        local shunzi_arr = {};
    
        for i,v in ipairs(bucket) do
            if #v ~= 0 then
                table.insert(cont_pos, v[1]);
                -- 获取一个顺子
                if #cont_pos == 5 then
                    -- 取出顺子
                    local shunzi = copy_array(cont_pos);
                    
                    if not isTHua(cards, shunzi) then
                        table.insert(shunzi_arr, shunzi);
                    end
                    table.remove(cont_pos, 1);
                end
            else
                cont_pos = {};
            end
        end
        
        -- 如果最后还有连续4次相连说明是: 10 J Q K
        if #cont_pos == 4 then
            -- A存在
            if #bucket[1] ~= 0 then
                table.insert(cont_pos, bucket[1][1]);
                if not isTHua(cards, cont_pos) then
                    table.insert(shunzi_arr, cont_pos);
                end
            end
        end
    
        local ranks = {};
        for i,shunzi in ipairs(shunzi_arr) do
            local newcards = copy_array(cards);
            local rmcards = rm_arr_by_pos(newcards, shunzi);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
        
        return ranks;
    end
    
    -- 识别三张，存在大于三张则失败
    local function regSZhangFunc(cards, lv)
        local bucket = get_pos_bucket(cards);
        
        local max_val;
        local wulong = {};
    
        for i,v in ipairs(bucket) do
            -- 说三张就三张, 不是三张或大于三张我不要, 谢谢
            if #v > 3 then
                return {};
            elseif #v == 3 then
                if max_val ~= 1 then
                    max_val = i;
                end
            elseif #v == 1 then
                table.insert(wulong, v[1]);
            end
        end
    
        local ranks = {};
        if max_val then
            -- 取两张最小的散牌
            local splitcards;
            
            if lv < 3 then
                -- 没有散牌就组不成5张的三张类型的牌组
                if #wulong < 2 then return {}; end
                -- 取出两张乌龙
                table.sort(wulong, function (a, b) return singleCardCompareValSmaller(cards[a]%0x10, cards[b]%0x10) end);
                splitcards = split_array(wulong, 1, 2);
            end
            
            local newcards = copy_array(cards);
            local szhang = merge_array(bucket[max_val], splitcards);
            local rmcards = rm_arr_by_pos(newcards, szhang);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
        return ranks;
    end
    
    -- 识别两对，存在待遇两对则失败
    local function regDDuiFunc(cards, lv)
        -- 三张实在凑不出两对
        if lv == 3 then
            return {};
        end
        
        local bucket = get_pos_bucket(cards);
        local max_val;
        local min_val;
        local min_single;
        -- 取最大的一个对子 + 最小的对子
        for i,v in ipairs(bucket) do
            -- 说对子就对子, 不是对子, 不是对子或大于对子我不要, 谢谢
            if #v > 2 then
                return {};
            elseif #v == 2 then
                if max_val ~= 1 then
                    max_val = i;
                end
    
                -- 取除1以外的最小牌
                if not min_val or min_val == 1 then
                    min_val = i;
                end
    
            elseif #v == 1 then
                -- 取除1以外的最小牌
                if not min_single or min_single == 1 then
                    min_single = i
                end
            end
        end
        
        local ranks = {};
    
        if min_val and max_val and min_val ~= max_val then
            local ddui_pos = merge_array(bucket[max_val], bucket[min_val]);
            local newcards = copy_array(cards);
            local rmcards = rm_arr_by_pos(newcards, ddui_pos);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
    
        return ranks;
    end
    
    -- 识别一对，存在大于一对则失败
    local function regDuiFunc(cards, lv)
        local bucket = get_pos_bucket(cards);
        
        local max_val;
        local wulong = {};
        
        for i,v in ipairs(bucket) do
            -- 说对子就对子, 不是对子, 不是对子或大于对子我不要, 谢谢
            if #v > 2 then
                return {};
            elseif #v == 2 then
                -- 对A 最大
                if max_val ~= 1 then
                    max_val = i;
                end
            elseif #v == 1 then
                table.insert(wulong, v[1]);
            end
        end
        
        local ranks = {};
        
        if max_val then
            -- 中道取三张最小的散牌
            -- 头道取一张最小的散牌
            local split_len = lv == 3 and 1 or 3;
            table.sort(wulong, function (a, b) return singleCardCompareValSmaller(cards[a]%0x10, cards[b]%0x10) end);
            local splitcards = split_array(wulong, 1, split_len);
            
            local newcards = copy_array(cards);
            local dui = merge_array(bucket[max_val], splitcards);
            local rmcards = rm_arr_by_pos(newcards, dui);
            table.insert(ranks, {cards = rmcards, next = newcards});
        end
        
        return ranks;
    end
    
    local function regWLongFunc(cards, lv)
        local bucket = get_pos_bucket(cards);
        
        for i,v in ipairs(bucket) do
            -- 说乌龙就乌龙, 不是乌龙我不要, 谢谢
            if #v > 1 then
                return {};
            end
        end
    
        local newcards = copy_array(cards);
        
        if lv == 3 then
            table.sort(newcards, singleCardCompareValSmaller);
            local three_cards, last_cards = split_array(newcards, #newcards-2, #newcards);
            
            return {
       {cards = three_cards, next = last_cards}};
        else
            table.sort(newcards, singleCardCompareValSmaller);
            
            local max_card = newcards[#newcards];
            table.remove(newcards, #newcards);
            
            local splitcards, leftcards = split_array(newcards, 1, 4);
            table.insert(splitcards, 1, max_card);
            
            return {
       {cards = splitcards, next = leftcards}};
        end
    end
    -- 类型排序
    local regTypeList = {
        {get = regWLongFunc; tp = 1; weight=0;};
        {get = regDuiFunc; tp = 2; weight=2;};
        {get = regDDuiFunc; tp = 3; weight=3;};
        {get = regSZhangFunc; tp = 4; weight=4;};
        {get = regShZiFunc; tp = 5; weight=5;};
        {get = regTHuaFunc; tp = 6; weight=6;};
        {get = regHLuFunc; tp = 7; weight=7;};
        {get = regTZhiFunc; tp = 8; weight=8;};
        {get = regTHShunFunc; tp = 9; weight=9;};
        {get = regWTongFunc; tp = 10; weight=10;};
    };
    -- 递归识别
    local function calcTypeRanks(cards, lv, tp)
        if not lv then lv = 1; end
        if not tp then tp = #regTypeList; end
        
        if lv > 3 then
            return cards;
        elseif lv == 3 and tp > 4 then
            tp = 4;
        end
        
        -- 尾道不获取乌龙类型的牌
        local bottom_tp = 1;
        if lv == 1 then bottom_tp = 2; end
     
        local ranks = {};
        for i = tp, bottom_tp, -1 do
            local regType = regTypeList[i];
            local tranks = regType.get(cards, lv);
            
            if #tranks ~= 0 then
                for ii, trank in ipairs(tranks) do
                    local rank = {};
                    -- debug
                    rank.cards = trank.cards;
                    rank.tp = i;
                    rank.next = calcTypeRanks(trank.next, lv + 1, i);
                    table.insert(ranks, rank);
                end
            end
        end
        
        return ranks;
    end
    --------------------------------------以上部分不依赖库---------------------------------------
    --------------------------------------以上部分不依赖库---------------------------------------
    --------------------------------------以上部分不依赖库---------------------------------------
    --[[ 
        return 2: c1 > c2
        return 1: c1 < c2
        return 0: c1 == c2
    ]]
    local function compareCard(c1, c2)
        local bc1 = ffi.new(string.format("BYTE[%d]", #c1), unpack(c1));
        local bc2 = ffi.new(string.format("BYTE[%d]", #c2), unpack(c2));
        local res = lib.CompareCard(bc1, bc2, #c1, #c2, bOnlyCompareNumber, bFuncVersion);
        return res
    end
    
    local function getAllRanks(cards)
        local all_ranks = calcTypeRanks(cards);
        local ranks = {};
        local special_ranks = {};
        
        for i,v in ipairs(all_ranks) do
            for ii,vv in ipairs(v.next) do
                for iii,vvv in ipairs(vv.next) do
                    local leftcards = vvv.next;
                    local rank = {
                        {cards = v.cards, tp = v.tp}, 
                        {cards = vv.cards, tp = vv.tp}, 
                        {cards = vvv.cards, tp = vvv.tp}
                    };
                    if #leftcards ~= 0 then
                        table.sort(leftcards, singleCardCompareValSmaller);
                        for x,y in ipairs(rank) do
                            local length = x == 3 and 3 or 5;
                            local leftlen = length-#y.cards;
                            
                            if leftlen ~= 0 then
                                local wl = split_array(leftcards, 1, leftlen);
                                for xx,yy in ipairs(wl) do
                                    table.insert(y.cards, yy);
                                end
                            end
                        end
                    end
                    -- 检测有没有倒水, 不同类型的绝对不会倒水, 同类型的可能倒水
                    if compareCard(rank[1].cards, rank[2].cards) ~= 1 then
                        -- 特殊类型的加入到特殊类型组合当中
                        if rank[3].tp == CT_THREE or rank[2].tp >= CT_FIVE_THREE_DEOUBLE or rank[1].tp > CT_FIVE_THREE_DEOUBLE then
                            table.insert(special_ranks, rank);
                        else
                            table.insert(ranks, rank);
                        end
                    end
                end
            end
        end
        -- 有特殊牌型，优先返回特殊牌型
        if #special_ranks ~= 0 then
            return special_ranks;
        end
        return ranks;
    end
    
    --获得牌型信息
    --return  配型,[特殊牌型数据]
    local function getCardType(data, cnt, spmydata, ver)
        if type(data) == 'table' then    
            data = ffi.new('BYTE[13]', unpack(data));
        end
        lib.SortCardList(data,  cnt, ffi.C.enDescend);
        local n = lib.GetCardType(data,  cnt, spmydata or spcard, ver or bFuncVersion);
        return n, spmydata or spcard;
    end
    
    --[[ 取特殊牌型的排列组合
    ]]
    local function getSpecialType(cards)
        local specialcards = ffi.new("BYTE[13]");
        local tp = getCardType(cards, #cards, specialcards);
        -- 返回不为0则为特殊牌型
        if tp ~= 0 then
            local str = ffi.string(specialcards, ffi.sizeof(specialcards));
            local first = {string.byte(str, 1, 3)};
            local second = {string.byte(str, 4, 8)};
            local third = {string.byte(str, 9, 13)};
            return first, second, third, tp; 
        end
    end
    
    local function chooseXdaoMax(allranks, level)
        local len = #allranks;
        local xdao = allranks[1];
        local ranks = {allranks[1]};
        if xdao then
            for i=2, len, 1 do
                -- 如果为头道,类型则应该比绝对大小
                if level == 3 then
                    if compareCard(xdao[level].cards, allranks[i][level].cards) == 1 then
                        xdao = allranks[i];
                        ranks = {allranks[i]};
                    end
                elseif xdao[level].tp < allranks[i][level].tp then
                    xdao = allranks[i];
                    ranks = {allranks[i]};
                elseif xdao[level].tp == allranks[i][level].tp then
                    table.insert(ranks, allranks[i]);
                end
            end
        end
        return ranks;
    end
    
    local function getMaxWeightRanks(allranks)
        local weight_sum = 0;
        local ranks = {allranks[1]};
    
        for i,v in ipairs(allranks) do
            
            local sum = 0;
            for ii,vv in ipairs(v) do
                sum = regTypeList[vv.tp].weight + sum;
            end
            
            if sum > weight_sum then
                ranks = {v};
                weight_sum = sum;
            elseif sum == weight_sum then
                table.insert(ranks, v);
            end
        end
        return ranks;
    end
    
    local function getBestRank(cards, expect, filter_priority)
        if not filter_priority then filter_priority = {2,3,1}; end
    
        -- 有特殊牌型直接返回
        local first, second, last, tp = getSpecialType(cards);
        if first then
            return first, second, last, tp;
        end
        -- 遍历所有牌型
        local allranks = getAllRanks(cards);
        
        -- 取权重值最高的组合
        local maxranks = getMaxWeightRanks(allranks);
        
        -- 按大中小的方式过滤,头道取卡牌值最大的,其余两道取类型最大值
        maxranks = chooseXdaoMax(maxranks, filter_priority[1]);
        maxranks = chooseXdaoMax(maxranks, filter_priority[2]);
        maxranks = chooseXdaoMax(maxranks, filter_priority[3]);
        
        -- 过滤重复选项, 或者不过滤，随机选取一项
        --local outrank = filterSameCards(maxrank);
        local outrank = maxranks[math.random(#maxranks)];
        first = outrank[3].cards;
        second = outrank[2].cards;
        last = outrank[1].cards;
    
        table.sort(first, singleCardCompareValSmaller);
        table.sort(second, singleCardCompareValSmaller);
        table.sort(last, singleCardCompareValSmaller);
        return first, second, last;
    end
    
    local function getRank(cards, expect, filter_priority)
        if not filter_priority then filter_priority = {2,3,1}; end
    
        -- 有特殊牌型直接返回
        local first, second, last, tp = getSpecialType(cards);
        if first then
            return first, second, last, tp;
        end
        -- 遍历所有牌型
        local allranks = getAllRanks(cards);
        
        local maxranks = allranks;
        -- 按大中小的方式过滤,头道取卡牌值最大的,其余两道取类型最大值
        maxranks = chooseXdaoMax(maxranks, filter_priority[1]);
        maxranks = chooseXdaoMax(maxranks, filter_priority[2]);
        maxranks = chooseXdaoMax(maxranks, filter_priority[3]);
        
        -- 过滤重复选项, 或者不过滤，随机选取一项
        --local outrank = filterSameCards(maxrank);
        local outrank = maxranks[math.random(#maxranks)];
        first = outrank[3].cards;
        second = outrank[2].cards;
        last = outrank[1].cards;
    
        table.sort(first, singleCardCompareValSmaller);
        table.sort(second, singleCardCompareValSmaller);
        table.sort(last, singleCardCompareValSmaller);
        return first, second, last;
    end
    
    return {
        getAllRanks = getAllRanks;
        getRank = getRank;
        getBestRank = getBestRank;
        make_ranks = make_ranks;
    }