麻将胡牌问题

最新推荐文章于 2021-06-02 21:10:42 发布
最新推荐文章于 2021-06-02 21:10:42 发布
阅读量823 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liujiao1988/article/details/103472147
版权

前言

麻将，起源于中国，是一种中国古人发明的博弈游戏，流行于华人文化圈中。经过多年发展，形成多种地区特色的玩法，麻将的胡牌也有一定特定的组合。

这里就复盘一个关于四川麻将胡牌的问题，题目来源： 一人麻将。

2641798-d02078303b732c63.png
四川麻将

题目

时间限制:10000ms
单点时限:1000ms
内存限制:256MB
描述
小Hi在北方的暖气里温暖如春，小Ho却在南方的艳阳里感受大雪纷飞。距离使得他们连一起打麻将的机会都没有，失落的小Hi一个人玩起了麻将。

小Hi玩的是四川麻将，因此只有3种序数牌万、筒、条，每种花色一到九各4张。

小Hi起手拥有14张牌，之后小Hi每摸一张牌后，如果没有胡牌，就出一张牌，直至胡牌或牌被摸光。反正一个人玩又赢不到小Ho的钱，因此小Hi永远也不会选择暗杠。

胡牌的规则如下：

手中14张牌最多只能属于两个花色。

手中14张牌的牌型须满足下列两个条件之一：

1）3 + 3 + 3 + 3 + 2，其中的3代表一坎（指同花色且同数字、或同花色且数字相连的三张牌），其中的2代表一个对子（指两张同花色且同数字的牌）。

2）2 × 7，即14张牌构成7个对子，特别的，四张花色数字全相同的牌可以看作两个对子。
万、筒、条分别记为a, b, c，以下对能胡牌的牌型举出一些例子：

a1 a2 a3 a5 a5 a5 c3 c4 c5 c5 c6 c7 c7 c7

b2 b2 b5 b5 b7 b7 b8 b8 c1 c1 c2 c2 c3 c3

现给出小Hi的起手牌，并按顺序给出场上其余小Hi将要摸的牌。（小Hi只拿出了一副麻将的一部分牌玩，因此并不是每张牌都会被摸到。）

请计算小Hi最早在摸第几张牌之后就可能胡牌，天胡（起手牌构成胡牌牌型）记为第0张。无法胡牌输出-1。

输入
每张牌用a, b或c其后紧接一个数字1-9表示。

第一行是一个正整数n (n <= 94)，代表将要摸的牌。

第二行是14张手牌。

第三行是n张底牌，按摸牌顺序给出。

输出
输出一个整数，代表最早在摸第几张牌之后可能胡牌，无法胡牌输出-1。

样例输入

12
a1 a1 a1 a2 a3 a4 a5 a6 a7 a8 a9 a9 a9 c1
c2 b1 b2 b4 b5 c1 b7 b8 a1 a2 a3 a4

样例输出

6

分析

首先，这道题的数据量很小，牌数一共只有96张，每钟花色也只有36张，所以不用过多考虑算法可能超时的问题，只需要把逻辑理清楚即可。

然后不要被打牌的流程所禁锢，就是摸一张必须打一张出去，这样每次的最佳打法很难确定。其实对于我们来说是拥有上帝视角的，知道后面所有牌的顺序，所以不用每摸一张牌就考虑最佳14张牌的排布。

那么，我们只需要摸一张就往数据集里添加一张牌，然后看是否能找出14张牌来胡牌就行了。

int main(int argc, const char * argv[]) {
    cin>>n;
    for (int i = 0; i < 14; i++) {
        string m;
        cin>>m;
        input(m);
    }
    vector<string> tm;
    for (int i = 0; i < n; i++) {
        string m;
        cin>>m;
        tm.push_back(m);
    }
    int res = 0;
    bool flag = check();
    while (!flag && res < n) {
        input(tm[res]);
        res++;
        flag = check();
    }
    if (flag) {
        cout<<res<<endl;
    }
    else {
        cout<<-1<<endl;
    }
    return 0;
}

接下来确定胡牌的组合，一种是7对，另一种就是常规的1个对子，4砍。没有对子，那么铁定就胡不了，还有四川麻将最对只留两个花色，check函数就主要处理7对和胡不了的情况。

bool check()
{
    int da = 0;
    int db = 0;
    int dc = 0;
    for (int i = 1; i < 10; i++) {
        da += a[i] / 2;
        db += b[i] / 2;
        dc += c[i] / 2;
    }
    // a+b;
    if (da + db >= 7) {
        return true;
    }
    if (da + db > 0 && subCheck(a, b)) {
        return true;
    }
    
    // a+c;
    if (da + dc >= 7) {
        return true;
    }
    if (da + dc > 0 && subCheck(a, c)) {
        return true;
    }
    // b+c;
    if (db + dc >= 7) {
        return true;
    }
    if (db + dc > 0 && subCheck(b, c)) {
        return true;
    }
    
    return false;
}

最后需要判断常规的1+4的胡牌情况，首先把对子确定了，然后去查砍牌，查到4组就可以确定胡牌了。在不考虑3张一样牌成砍的情况下，查砍牌直接暴力从1开始就行了。

            for (int j = 1; j <= 7; j++) {
                int minX = min(min(tx[j], tx[j+1]), tx[j+2]);
                count += minX;
                tx[j] -= minX;
                tx[j+1] -= minX;
                tx[j+2] -= minX;
                
                int minY = min(min(ty[j], ty[j+1]), ty[j+2]);
                count += minY;
                ty[j] -= minY;
                ty[j+1] -= minY;
                ty[j+2] -= minY;
                
                if (count >= 4) {
                    return true;
                }
            }

对于3张一样牌成砍的情况，需要确定是把他们合起来做砍好，还是拆开和其他牌组合好。这个就需要判断拆开后是否能多砍牌组合。比如3个三万，我需要看一万、二万、四万、五万的个数情况，确定是否拿3个三万作为一砍。

            for (int j = 1; j < 10; j++) {
                if (tx[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(tx[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        tx[j] -= 3;
                        count++;
                    }
                }
                
                if (ty[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(ty[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        ty[j] -= 3;
                        count++;
                    }
                }
            }

整个subcheck，1+4情况：

bool subCheck(int *x, int *y)
{
    for (int i = 1; i < 10; i++) {
        if (x[i] >= 2) {
            int tx[10], ty[10];
            for (int j = 1; j < 10; j++) {
                tx[j] = x[j];
                ty[j] = y[j];
            }
            tx[i] -= 2;
            int count = 0;
            for (int j = 1; j < 10; j++) {
                if (tx[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(tx[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        tx[j] -= 3;
                        count++;
                    }
                }
                
                if (ty[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(ty[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        ty[j] -= 3;
                        count++;
                    }
                }
            }
            
            
            for (int j = 1; j <= 7; j++) {
                int minX = min(min(tx[j], tx[j+1]), tx[j+2]);
                count += minX;
                tx[j] -= minX;
                tx[j+1] -= minX;
                tx[j+2] -= minX;
                
                int minY = min(min(ty[j], ty[j+1]), ty[j+2]);
                count += minY;
                ty[j] -= minY;
                ty[j+1] -= minY;
                ty[j+2] -= minY;
                
                if (count >= 4) {
                    return true;
                }
            }
            
        }
        if (y[i] >= 2) {
            int tx[10], ty[10];
            for (int j = 1; j < 10; j++) {
                tx[j] = x[j];
                ty[j] = y[j];
            }
            ty[i] -= 2;
            int count = 0;
            
            for (int j = 1; j < 10; j++) {
                if (tx[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(tx[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        tx[j] -= 3;
                        count++;
                    }
                }
                
                if (ty[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(ty[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        ty[j] -= 3;
                        count++;
                    }
                }
            }
            
            
            for (int j = 1; j <= 7; j++) {
                int minX = min(min(tx[j], tx[j+1]), tx[j+2]);
                count += minX;
                tx[j] -= minX;
                tx[j+1] -= minX;
                tx[j+2] -= minX;
                
                int minY = min(min(ty[j], ty[j+1]), ty[j+2]);
                count += minY;
                ty[j] -= minY;
                ty[j+1] -= minY;
                ty[j+2] -= minY;
                
                if (count >= 4) {
                    return true;
                }
            }
        }
    }
    return false;
}

结果

整个算法的时间复杂度为n×10×10×5，可以看到运行几乎没有耗费时间。

2641798-6e4309befa281cf7.png

完整代码：

//
//  main.cpp
//  一人麻将
//
//  Created by Jiao Liu on 7/2/19.
//  Copyright © 2019 ChangHong. All rights reserved.
//

#include <iostream>
#include <vector>

using namespace std;
int n,a[10],b[10],c[10];

bool subCheck(int *x, int *y)
{
    for (int i = 1; i < 10; i++) {
        if (x[i] >= 2) {
            int tx[10], ty[10];
            for (int j = 1; j < 10; j++) {
                tx[j] = x[j];
                ty[j] = y[j];
            }
            tx[i] -= 2;
            int count = 0;
            for (int j = 1; j < 10; j++) {
                if (tx[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(tx[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        tx[j] -= 3;
                        count++;
                    }
                }
                
                if (ty[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(ty[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        ty[j] -= 3;
                        count++;
                    }
                }
            }
            
            
            for (int j = 1; j <= 7; j++) {
                int minX = min(min(tx[j], tx[j+1]), tx[j+2]);
                count += minX;
                tx[j] -= minX;
                tx[j+1] -= minX;
                tx[j+2] -= minX;
                
                int minY = min(min(ty[j], ty[j+1]), ty[j+2]);
                count += minY;
                ty[j] -= minY;
                ty[j+1] -= minY;
                ty[j+2] -= minY;
                
                if (count >= 4) {
                    return true;
                }
            }
            
        }
        if (y[i] >= 2) {
            int tx[10], ty[10];
            for (int j = 1; j < 10; j++) {
                tx[j] = x[j];
                ty[j] = y[j];
            }
            ty[i] -= 2;
            int count = 0;
            
            for (int j = 1; j < 10; j++) {
                if (tx[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(tx[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        tx[j] -= 3;
                        count++;
                    }
                }
                
                if (ty[j] >= 3) {
                    int l = max(1, j-2);
                    int r = min(9, j+2);
                    vector<int> tmp;
                    for (int k = l; k <= r; k++) {
                        tmp.push_back(ty[k]);
                    }
                    int tCount = 0;
                    for (int k = 0; k < tmp.size()-2; k++) {
                        int minX = min(min(tmp[k], tmp[k+1]), tmp[k+2]);
                        tCount += minX;
                        tmp[k] -= minX;
                        tmp[k+1] -= minX;
                        tmp[k+2] -= minX;
                    }
                    if (tCount <= 1) {
                        ty[j] -= 3;
                        count++;
                    }
                }
            }
            
            
            for (int j = 1; j <= 7; j++) {
                int minX = min(min(tx[j], tx[j+1]), tx[j+2]);
                count += minX;
                tx[j] -= minX;
                tx[j+1] -= minX;
                tx[j+2] -= minX;
                
                int minY = min(min(ty[j], ty[j+1]), ty[j+2]);
                count += minY;
                ty[j] -= minY;
                ty[j+1] -= minY;
                ty[j+2] -= minY;
                
                if (count >= 4) {
                    return true;
                }
            }
        }
    }
    return false;
}

bool check()
{
    int da = 0;
    int db = 0;
    int dc = 0;
    for (int i = 1; i < 10; i++) {
        da += a[i] / 2;
        db += b[i] / 2;
        dc += c[i] / 2;
    }
    // a+b;
    if (da + db >= 7) {
        return true;
    }
    if (da + db > 0 && subCheck(a, b)) {
        return true;
    }
    
    // a+c;
    if (da + dc >= 7) {
        return true;
    }
    if (da + dc > 0 && subCheck(a, c)) {
        return true;
    }
    // b+c;
    if (db + dc >= 7) {
        return true;
    }
    if (db + dc > 0 && subCheck(b, c)) {
        return true;
    }
    
    return false;
}

void input(string m)
{
    if (m[0] == 'a') {
        a[m[1]-'0']++;
    }
    if (m[0] == 'b') {
        b[m[1]-'0']++;
    }
    if (m[0] == 'c') {
        c[m[1]-'0']++;
    }
}

int main(int argc, const char * argv[]) {
    cin>>n;
    for (int i = 0; i < 14; i++) {
        string m;
        cin>>m;
        input(m);
    }
    vector<string> tm;
    for (int i = 0; i < n; i++) {
        string m;
        cin>>m;
        tm.push_back(m);
    }
    int res = 0;
    bool flag = check();
    while (!flag && res < n) {
        input(tm[res]);
        res++;
        flag = check();
    }
    if (flag) {
        cout<<res<<endl;
    }
    else {
        cout<<-1<<endl;
    }
    return 0;
}
liujiao1988
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【华为练习题】求麻将清一色和牌问题
究极死胖兽的博客
02-14 7259
【华为练习题】求麻将清一色和牌问题 题目 题目描述： 清一色是麻将番种之一，指由一种花色的序数牌组成的和牌. 数字1-9，每个数字最多有4张牌 我们不考虑具体花色，我们只看数字组合。 刻子：三张一样的牌；如: 111, 222, 333, …, 999 顺子：三张连续的牌；如: 123, 234, 345, …, 789 对子：两张相同的牌；如: 11, 22, 33, …, 99 需要实现一个程...
麻将的胡牌算法
热门推荐
shinefire的博客
03-01 2万+
麻将
华为笔试题--麻将和牌问题
湖之风情的博客
09-13 2449
题目描述： 清一色是麻将番种之一，指由一种花色的序数牌组成的和牌. 数字1-9，每个数字最多有4张牌 我们不考虑具体花色，我们只看数字组合。 刻子：三张一样的牌；如: 111, 222, 333, ..., 999 顺子：三张连续的牌；如: 123, 234, 345, ..., 789 对子：两张相同的牌；如: 11, 22, 33, ..., 99 需要实现一个程序，判断给定牌，是否可以和牌（...
微软面试题 麻将胡牌算法
weixin_30872157的博客
03-22 224
1. 这个题目要求提供最终代码(C#) 2. 该最终代码必须可以编译,运行,并实现以下的业务功能 3. 限制时间一个小时, 包括阅读文档和提交代码的时间 业务功能: 给定若干张的麻将牌 (假设只有 万 一种类型,没有条和筒) 最终胡牌必须满足以下条件 　　所有的牌必须连成顺子或者3张 即:123 或者111 　　最后还要有一对, 例如 11 方法签名如下: bool ...
麻将胡牌判定的判定算法
嘿嘿
10-12 5309
麻将胡牌判定的判定算法 问题背景 : 简化了麻将规则,给定[1s-9s],[1b-9b],[1t-9t]一共27种牌,每种牌都有4张。需要判断给定的牌是不是胡牌。   胡牌的定义为: 14张牌里面由一个对子,四个坎组成。其中对子代表两张一样的牌,坎代表三张一样的牌,或者三张连续的牌(连续指: 1s,2s,3s | 4t,5t,6t)    举例： 1s,1s,2t,3t,4t,2t,3...
四川麻将胡牌算法
06-12
通过递归的算法实现四川麻将的胡牌算法，这里讲所有的牌进行排序，并调用递归的算法，判定这十四张牌是否能胡，能够成功运行。
麻将胡牌算法
02-03
各种语言的麻将胡牌算法。干货。 c++ c# lua go js麻将胡牌算法
C++麻将胡牌算法
08-29
时间复杂弃为 O(n) 可谓原地工作的 C++ 麻将胡牌 算法
麻将癞子胡牌算法
05-17
麻将癞子胡牌算法，效率超快。4个5个癞子都测试过，python语言写的。
网易互娱游戏笔试 麻将胡排
qq_24624539的博客
08-12 1187
a题目描述 七星不靠是中国麻将竞赛规则的番种，胡牌时由东南西北中发白7张，外加其他花色的 147、258、 369不相连 的牌型，且没有将牌而组成。 -百度百科 七星不靠中的七星是指:东西南北中发白，也就是牌中必须有这七张。而其它牌按下述 的来拼全: 东西南北中发白+147万+258饼+369条 东西南北中发白+147万+258条+369饼 东西南北中发白+147条+258万+369饼 东西南北中发白+147条+258饼+369万 东西南北中发白+147饼+258条+369万 东西南北中发白+147饼+25
华为笔试算法：清一色胡牌问题（java）
u014799309的博客
03-03 3432
题目描述： 清一色是麻将番种之一，指由一种花色的序数牌组成的和牌。数字1-9，每个数字最多有4张牌。我们不考虑具体花色，我们只看数字组合。 刻子：三张一样的牌；如: 111, 222, 333, ..., 999 顺子：三张连续的牌；如: 123, 234, 345, ..., 789 对子：两张相同的牌；如: 11, 22, 33, ..., 99 需要实现一个程序，判断给定牌，是否可以和牌（胡...
回溯算法-胡牌问题[组合问题的进阶]
qq_37080133的博客
06-02 199
原始题目：雀魂启动 题目的大致意思就是，有13张排，加一张，就能胡，用贵州话讲就是一对将，然后加四坎牌。 一坎牌可以是三个一样的碰，也可以是顺子。现在，让你用程序去判定任意一组13排是否能胡，并给出需要哪个牌来胡牌。 这个显然是一个经典的回溯问题，但是和我们常见的回溯问题又有一些区别，比如：组合问题 class Solution { public: vector<vector<int>> arrs; map<string,int> maps; ve
【东东打牌II】模拟
weixin_43676449的博客
03-27 210
题目 题意 东东有 A × B 张扑克牌。每张扑克牌有一个大小(整数，记为a，范围区间是 0 到 A - 1）和一个花色（整数，记为b，范围区间是 0 到 B - 1。 扑克牌是互异的，也就是独一无二的，也就是说没有两张牌大小和花色都相同。 “一手牌”的意思是你手里有5张不同的牌，这 5 张牌没有谁在前谁在后的顺序之分，它们可以形成一个牌型。 我们定义了 9 种牌型，如下是 9 种牌型的规则，我...
【面试】麻将胡牌【字节跳动】【游戏规则】【递归】
weixin_41888257的博客
07-18 1404
【字节跳动实习面试 2019-01-07】 一、题目描述 给定长度为14的整型数组，判断是否胡牌2 + 3*4 dd + (abc or aaa) * 4 范围 1～9之间代表数字1～9 形如 111 222 333 456 77 返回True 形如 111 223 345 67 999 返回True 形如 111 222 333 457 99 返回False 二、解题思路 把规则拆分开，分开讨论，不可能一个式子包括所有情况的 from collections import Counter def
麻将AI & 不完全信息博弈学习笔记（完结）
咸鱼代码屋
04-19 8102
不完全信息博弈学习笔记 前言 在这学期的数据结构必修课中，老师向我们提供了两道题： 其一是六子棋问题； 其二是麻将AI问题； 前者是经典的完全信息博弈问题，根据我已有的知识，利用博弈树和合理的剪枝可以提供一种高效的解法（当然只是框架思路，具体实现会伴随各种细节问题） 而对于后者，也就是不完全信息博弈，目前大二的博主基本没有任何相对应的知识储备，也正是出于想扩展自己的专业知识这样一种想法，博主与另外...
麻将胡牌判定的问题
banji5552的博客
08-09 324
问题描述： 前面去面试，需要设计一个算法检测麻将是否可以胡牌。简单描述如下：胡牌的规则为，有一个同样的两张牌做将，然后剩下的组成ABC或者AAA的形式。假设有13张牌，都是万字。不存在碰或者杠等特殊情况，判断这13张牌是否可以听牌。如果可以，输出此时作为将的牌和可以听的牌。 实现的代码如下： 1 package com.rampage.algorithm.base; ...
golang麻将胡牌算法
最新发布
10-29
麻将胡牌算法是用来判断一手牌是否能够胡牌的算法，它是在麻将游戏中非常重要的一部分。 Golang中可以使用递归的方式实现麻将胡牌算法。首先，我们需要定义麻将的牌型和点数，例如万、筒、索，以及相应的编号。然后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值