写一段代码判断一副麻将和不和，听没听，生成和牌和听牌的麻将

本文链接：https://blog.csdn.net/weixin_43952381/article/details/132053536

1，写段代码来判断麻将是不是和牌了。
2，写段代码不断生成能和牌的麻将。
3，写段代码不断生成能听牌的麻将，并输出听的是哪几张。
这三个本质上是一回事，我完成的是2和3。
先给出所有函数：

# import numpy as np
import random
import copy
# 原来的card是一长串，但是在中间操作了一通以后可能变短了，这时候外层的i就越界了
def judge_hu(card):
    card.sort()
    for i in range(len(card)):
        if len(card)==2:
            if card[0]==card[1]:
                return True
            else:
                return False
        if i > 0 and card[i] == card[i-1]:
            continue
        if contains_kezi(card,card[i]):
            copy_card = copy.deepcopy(card)
            new_card=erase_kezi(copy_card,copy_card[i])
            if judge_hu(new_card):
                return True
        if contains_shunzi(card,card[i]):
            copy_card = copy.deepcopy(card)
            new_card=erase_shunzi(copy_card,copy_card[i])
            if judge_hu(new_card):
                return True
    return False
def contains_kezi(card,item):
    if card.count(item) >= 3:
        return True
    return False
def erase_kezi(card,item):
    if card.count(item)>=3:
        for i in range(3):
            card.remove(item)
    return card
def contains_shunzi(card,item):
    if item + 1 in card and item + 2 in card:
        return True
    return False
def erase_shunzi(card,item):
    if item+1 in card and item+2 in card:
        card.remove(item)
        card.remove(item+1)
        card.remove(item+2)
    return card

def is_tingpai_this(card,new_item):
    card_copy=copy.deepcopy(card)
    card_copy.append(new_item)
    if judge_hu(card_copy):
        return True
    return False
def is_tingpai(card,least_ting=1):
    ting_num=0
    for i in range(1,10):
        if is_tingpai_this(card,i):
            ting_num+=1
    if ting_num>=least_ting:
        return True
    return False

如果是任务2，主函数如下：

episode=0
while True:
    episode+=1
    if episode>=10000:
        break
    if episode % 100 ==0:
        print("episode:"+str(episode))
    card = []
    for i in range(14):
        card.append(random.randint(1,9))
    # print(card[0])
    if judge_hu(card):
        print(card)
# card=[3,3,3,1,2,3,7,7]
# print(judge_hu(card))

如果是任务3，主函数如下：

least_ting=4
print("最少听牌数为" + str(least_ting) + "张的牌：")
episode=0
while True:
    episode+=1
    if episode>=10000:
        break
    if episode % 100 ==0:
        print("\nepisode:"+str(episode),end='')
    card = []
    for i in range(13):
        card.append(random.randint(1,9))


    if is_tingpai(card,least_ting=least_ting):
        if is_tingpai(card, least_ting=least_ting):
            card.sort()
            print("\n这副牌听了"+str(card))
            print("听的是",end=' ')
            for new_item in range(1,10):
                if is_tingpai_this(card,new_item):
                    print(new_item,end=' ')

# card=[3,3,3,1,2,3,7,7]
# print(judge_hu(card))

这个逻辑是什么呢？就是你拿到14张牌，你先判断拿掉3张（顺子或刻子）以后这个牌能不能和。也就是判断11张能不能和。怎么判断这11张呢？那就看再拿掉3张能不能和。以此类推……直到最后看那2张能不能和。那两张如果一样，就和了，反之没和。
当然，14张牌，你拿掉3张（顺子或刻子）有好多种拿法，也就是有好几种剩下11张牌的情况。只要它们中有1种情况能和，那就是和了。
比方说

11123666777888

拿掉111以后，和不了，但拿掉123以后，就和了。我们也可以拿掉666，678，777，888，剩下11张牌。就是从14张拿掉3张，有7种情况。7种里面有一种能和就行。然后这11张牌怎么判断呢？每种情况，都考虑所有拿掉3张的情况……这就是个递归。
我们怎么考虑所有拿掉三张的情况呢？
以

11123666777888

来说，从头到尾遍历（前提是这牌得排好序才行），然后我们不看重复值，那就是123678。对于1来说，考虑它构成的顺子：123，和它构成的刻子：111，它们都可以被拿掉。这就两种情况了。
情况1：拿掉三张以后的11张是：

11666777888

情况2：拿掉3张以后的11张是：

23666777888

然后看2：它构成的顺子是234，但是这副牌里没有，所以就跳过；它构成的刻子是222，这副牌里也没有，就跳过。然后看6，7，8。
以此类推。
最后判断的就是剩下的两张牌，我们希望它是将牌（两个一样的）比如剩下的牌是

那就和了。
比如剩下的牌是：

那就没和。

细节

这里面有个细节，就是你递归判断完以后，有个问题，就是一开始14张牌，拿掉三张剩下11张，你判断这个11张的时候，如果这11张没和，那么你return False然后返回到上一个函数的时候，牌就剩下11张了。就是主函数给子函数的时候，是14张，子函数返回给主函数的时候，剩下11张了。这就有问题了。
有两个办法：
1，主函数给子函数的时候，把牌复制一份，给子函数。这样子函数判断完，剩11张了，但是是复制过的牌，不影响主函数。
注意python有个深复制浅复制的问题，这里我们要的是深复制。
2，子函数判断完以后，把11张牌还原到14张，再返回给主函数。
我用的是方法1。但我个人觉得方法2更好，因为方法1复制那副牌的时候额外耗费了空间。不过方法1写起来简单。