精华内容
下载资源
问答
  • python实现24点游戏

    2015-12-29 13:28:59
    python实现24点游戏:由计算机随机产生4个数字(也可由用户自己输入),然后由计算机填+-*/和(),使计算结果等于24
  • Python实现24点游戏

    2021-05-10 20:14:09
    问题描述 24点游戏是经典的纸牌益智游戏。 常见游戏规则: 从扑克中每次取出4张牌。使用加减乘除,第一个能得出24者为赢。(其中,J代表11,Q代表12,K代表13,A代表1),按照要求编程解决24点游戏

    问题描述

    24点游戏是经典的纸牌益智游戏。
    常见游戏规则:
    从扑克中每次取出4张牌。使用加减乘除,第一个能得出24者为赢。(其中,J代表11,Q代表12,K代表13,A代表1),按照要求编程解决24点游戏。
    基本要求: 随机生成4个代表扑克牌牌面的数字字母,程序自动列出所有可能算出24的表达式,用擅长的语言(C/C++/Java或其他均可)实现程序解决问题。
    1.程序风格良好(使用自定义注释模板)
    2.列出表达式无重复。

    内容

    算法分析

    1.函数random_number()随机生成4个1~13范围内的整数;
    2.poke()函数将生成的四个随机整数以扑克牌的形式输出(A,2,3,4,5,6,7,8,9,10,J,Q,K);
    3.fun()函数进行两个数的四则运算;
    4.calculate()函数计算所有情况;
    5.timer()函数实现计时器功能;
    6.player()函数就是玩家进行游戏:
    玩家初始生命值为3,分数为0,若随机生成的四个数可以组成24并且玩家能写出其中一种表达式则可得十分,若四张牌无法完成24点或者玩家未在规定的时间内完成,则生命值减1,减到0游戏结束。

    概要设计

    流程图:
    在这里插入图片描述

    代码如下:

    """
    @author: CheYuHang
    @software: PyCharm
    @file: puke.py
    @time: 2021/5/9 12:35
    """
    
    import random
    import time
    
    def random_number():
        """
        随机生成四个整数
        :return:
        """
        y = []
        for i in range(4):
            y.append(random.randint(1,13))
        return y
    
    
    # def fun(k,l,i):
    #     """
    #     两个数据之间的运算
    #     :param k:
    #     :param l:
    #     :param i:
    #     :return:
    #     """
    #     if i==0:
    #         tem = k+l
    #         return tem
    #     elif i==1:
    #         tem = k-l
    #         return tem
    #     elif i==2:
    #         tem = k*l
    #         return tem
    #     elif i==3:
    #         if l==0:
    #             return
    #         else:
    #             tem = k/l
    #             return tem
    def fun(k, l, i):
        """
        两个数据之间的运算
        :param k:
        :param l:
        :param i:
        :return:
        """
        if i==0:
            if (type(k) is int or type(k) is float) and (type(l) is int or type(l) is float):
                tem = k + l
                return tem
            else:
                return
        elif i==1:
            if (type(k) is int or type(k) is float) and (type(l) is int or type(l) is float):
                tem = k - l
                return tem
            else:
                return
        elif i==2:
            if (type(k) is int or type(k) is float) and (type(l) is int or type(l) is float):
                tem = k * l
                return tem
            else:
                return
        elif i==3:
            if (type(k) is int or type(k) is float) and (type(l) is int or type(l) is float):
                if l != 0:
                    tem = k / l
                    return tem
                else:
                    return
            else:
                return
    
    
    def poker(y):
        """
        将生成的随机数以扑克牌的形式输出
        :param y:
        :return:
        """
        y1 = y.copy()
        while 1 in y1 or 11 in y1 or 12 in y1 or 13 in y1:
            if 1 in y1:
                z = y1.index(1)
                y1.remove(1)
                y1.insert(z, 'A')
            if 11 in y1:
                z = y1.index(11)
                y1.remove(11)
                y1.insert(z, 'J')
            if 12 in y1:
                z = y1.index(12)
                y1.remove(12)
                y1.insert(z, 'Q')
            if 13 in y1:
                z = y1.index(13)
                y1.remove(13)
                y1.insert(z, 'K')
            continue
        # if 1 in y1:
        #     z = y1.index(1)
        #     y1.remove(1)
        #     y1.insert(z, 'A')
        # if 11 in y1:
        #     z = y1.index(11)
        #     y1.remove(11)
        #     y1.insert(z, 'J')
        # if 12 in y1:
        #     z = y1.index(12)
        #     y1.remove(12)
        #     y1.insert(z, 'Q')
        # if 13 in y1:
        #     z = y1.index(13)
        #     y1.remove(13)
        #     y1.insert(z, 'K')
        print("随机抽取的四张牌为:", y1[0], y1[1], y1[2], y1[3])
    
    
    # y = random_number()
    # print(y)
    # y = [7, 1, 11, 6]
    # x = ['+', '-', '*', '/']
    
    
    def calculate(y):
        """
        计算,求出符合题目要求的
        :return:
        """
        result_list = []
        result_list2 = []
        temp = 0
        temp1 = 0
        temp2 = 0
        for i in range(0,4):
            for j in range(0,4):
                for k in range(0,4):
                    for l in range(0,4):
                        if i == j or i == k or i == l or j == k or j == l or k == l:
                            continue
                        else:
                            for n in range(0,4):
                                for m in range(0,4):
                                    for p in range(0,4):
                                        for q in range(0,6):
                                            result = 0
                                            if q == 0:
                                                temp1 = fun(y[i], y[j], n)
                                                temp1 = fun(temp1, y[k], m)
                                                result = fun(temp1, y[l], p)
                                                if result==24:
                                                    result_list.append(
                                                        "(({0}{1}{2}){3}{4}){5}{6}=24".format(y[i], x[n], y[j], x[m], y[k],
                                                                                              x[p], y[l]))
                                                    result_list2.append(
                                                        "(({0}{1}{2}){3}{4}){5}{6}".format(y[i], x[n], y[j], x[m], y[k],
                                                                                           x[p], y[l]))
                                                    # print("(({0}{1}{2}){3}{4}){5}{6}=24".format(y[i], x[n], y[j], x[m], y[k],
                                                    #                                             x[p], y[l]))
                                                    temp += 1
                                                #break
                                                continue
                                            elif q == 1:
                                                temp1 = fun(y[i], y[j], n)
                                                temp2 = fun(y[k], y[l], p)
                                                result = fun(temp1, temp2, m)
                                                if result == 24:
                                                    result_list.append(
                                                        "({0}{1}{2}){3}({4}{5}{6})=24".format(y[i], x[n], y[j], x[m], y[k],
                                                                                              x[p], y[l]))
                                                    result_list2.append(
                                                        "({0}{1}{2}){3}({4}{5}{6})".format(y[i], x[n], y[j], x[m], y[k],
                                                                                           x[p], y[l]))
                                                    # print("({0}{1}{2}){3}({4}{5}{6})=24".format(y[i], x[n], y[j], x[m], y[k],
                                                    #                                             x[p], y[l]))
                                                    temp += 1
                                                #break
                                                continue
                                            elif q == 2:
                                                temp1 = fun(y[j], y[k], m)
                                                temp1 = fun(y[i], temp1, n)
                                                result = fun(temp1, y[l], p)
                                                if result == 24:
                                                    result_list.append(
                                                        "({0}{1}({2}{3}{4})){5}{6}=24".format(y[i], x[n], y[j], x[m], y[k],
                                                                                              x[p], y[l]))
                                                    result_list2.append(
                                                        "({0}{1}({2}{3}{4})){5}{6}".format(y[i], x[n], y[j], x[m], y[k],
                                                                                           x[p], y[l]))
                                                    # print("({0}{1}({2}{3}{4})){5}{6}=24".format(y[i], x[n], y[j], x[m], y[k],
                                                    #                                             x[p], y[l]))
                                                    temp += 1
                                                # break
                                                continue
                                            # elif q==3:
                                            #     temp1 = fun(y[k], y[l], m)
                                            #     temp2 = fun(y[i], y[j], p)
                                            #     result = fun(temp1, temp2, n)
                                            #     if result == 24:
                                            #
                                            #         print("({0}{1}{2}){3}({4}{5}{6})=24".format(y[i], x[n], y[j], x[m], y[k],
                                            #                                                     x[p], y[l]))
                                            #         temp += 1
                                            #         break
                                            elif q == 3:
                                                temp1 = fun(y[j], y[k], m)
                                                temp1 = fun(temp1, y[l], p)
                                                result = fun(y[i], temp1, n)
                                                if result == 24:
                                                    result_list.append(
                                                        "{0}{1}(({2}{3}{4}){5}{6})=24".format(y[i], x[n], y[j], x[m], y[k],
                                                                                              x[p], y[l]))
                                                    result_list2.append(
                                                        "{0}{1}(({2}{3}{4}){5}{6})".format(y[i], x[n], y[j], x[m], y[k],
                                                                                           x[p], y[l]))
                                                    # print("{0}{1}(({2}{3}{4}){5}{6})=24".format(y[i], x[n], y[j], x[m], y[k],
                                                    #                                             x[p], y[l]))
                                                    temp += 1
                                                #break
                                                continue
                                            elif q == 4:
                                                temp1 = fun(y[k], y[l], p)
                                                temp1 = fun(y[j], temp1, m)
                                                result = fun(y[i], temp1, n)
                                                if result == 24:
                                                    result_list.append(
                                                        "{0}{1}({2}{3}({4}{5}{6}))=24".format(y[i], x[n], y[j], x[m], y[k],
                                                                                              x[p], y[l]))
                                                    result_list2.append(
                                                        "{0}{1}({2}{3}({4}{5}{6}))".format(y[i], x[n], y[j], x[m], y[k],
                                                                                           x[p], y[l]))
                                                    # print("{0}{1}({2}{3}({4}{5}{6}))=24".format(y[i], x[n], y[j], x[m], y[k],
                                                    #                                             x[p], y[l]))
                                                    temp += 1
                                                #break
                                                continue
        return temp, result_list, result_list2
        # if temp == 0:
        #     print("这四张牌无法完成24点游戏")
        # else:
        #     print()
    
    
    def timer():
        """
        计时器
        :return:
        """
        return time.perf_counter()
    
    
    def player():
        """
        玩家进行游戏
        :return:
        """
        hit_point = 3
        score = 0
        print("==================================================")
        print("==                     24点游戏                  ==")
        print("==游戏玩家开始时的血量为:{0}                          ==".format(hit_point))
        print("==游戏玩家开始时的分数为:{0}                          ==".format(score))
        print("==是否开始游戏:Y or N                             ==")
        print("==================================================")
        use = input()
        while use == 'Y':
            y = random_number()
            poker(y)
            result, result_list, result_list2 = calculate(y)
            if result == 0:
                print("这四个数无法完成24点游戏,生命值扣一")
                hit_point -= 1
                if hit_point !=0:
                    print("你当前的生命值为:{0}  是否继续:Y/N".format(hit_point))
                    use = input()
                else:
                    print("生命值为0,游戏结束")
                    break
                # break
    
                continue
            elif result != 0:
                print("请玩家输入正确表达式:(A为1,J为11,Q为12,K为13)")
                # for i in result_list:
                #     print(i)
                start_time = timer()
                player_expression = input()
                end_time = timer()
                if end_time-start_time <= 10:
                    if player_expression in result_list2:
                        print("回答正确,加十分")
                        score += 10
                        print("这四张牌所有的组合为:")
                        for i in result_list:
                            print("{0}".format(i))
                        print("是否继续:Y/N")
                        use = input()
                    else:
                        print("回答错误:生命值扣一")
                        hit_point -= 1
                        if hit_point != 0:
                            print("你当前的生命值为:{0} 得分为{1}".format(hit_point, score))
                            print("这四张牌所有的组合为:")
                            for i in result_list:
                                print("{0}".format(i))
                            print("是否继续:Y/N")
                            use = input()
                        else:
                            print("生命值为0,游戏结束")
                            break
                        # print("这四张牌所有的组合为:")
                        # for i in result_list:
                        #     print("{0}".format(i))
                        # print("是否继续:Y/N")
                        # use = input()
                else:
                    print("未在规定时间内答完,生命值减一")
                    hit_point -= 1
                    print("是否继续:Y/N")
                    use = input()
                continue
                    # continue
        print("你最后的生命值为:{0};最终得分为:{1}".format(hit_point, score))
    
    # y = random_number()
    # # y = [5,9,3,7]
    # x = ['+', '-', '*', '/']
    # poker(y)
    # calculate(y)
    
    x = ['+', '-', '*', '/']
    player()
    

    测试

    测试的时候出现这个错误:unsupported operand type(s) for +: ‘NoneType’ and ‘int’
    在这里插入图片描述
    将fun()函数进行了修改:
    在这里插入图片描述

    调试

    运行程序:出现游戏页面
    在这里插入图片描述
    玩家输入Y进行游戏,这时,会自动生成四张扑克,电脑自动判断这四个数是否可以完成24点游戏,若可以完成,则需要玩家在规定的时间内完成一个表达式的输入,若输入合理,则得10分并输出所有可能的表达式,若输入不合理或者未在规定时间内完成,则扣1点生命值,如果生命值为0或者玩家不继续进行游戏,则游戏结束:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    玩家未在规定时间内完成:
    在这里插入图片描述
    第二次测试:
    在这里插入图片描述
    在这里插入图片描述

    心得体会

    在做的过程中,比较难得就是这四个随机数和四个运算符能有多少种排列组合,最后在比较下,使用括号对四个数进行分类比较合适(共四种情况)。
    在处理那个异常的情况下,在网上找资源,以及查阅资料,将那个异常解决了,这个是最花费时间的。

    展开全文
  • python+pyqt5实实现现24点点小小游游戏戏 这篇文章主要为大家详细介绍了python+pyqt5实现24点小游戏具有一定的参考价值感兴趣的小伙伴们可以参 考一下 本文实例为大家分 了python实现24点游戏的具体代码供大家参考...
  • Python+pyqt5实现24点游戏
  • 本文实例为大家分享了python实现24点游戏的具体代码,供大家参考,具体内容如下 描述:一副牌中A、J、Q、K可以当成是1、11、12、13。任意抽取4张牌,用加、减、乘、除(可加括号)把牌面上的数算成24。每张牌对应的...
  • Python 实现简单的24点游戏游戏规则实现思路 游戏规则 给出4个1-10的数,可改变顺序,4个数都要用上,通过加减乘除运算得到24. 实现思路 1. 通过使用循环列出4个数所有24种排列方式; 2. 将3个运算符插入到每两个数...

    Python 实现简单的24点游戏

    游戏规则

    给出4个1-10的数,可改变顺序,4个数都要用上,通过加减乘除运算得到24.

    实现思路

    1. 通过使用循环列出4个数所有24种排列方式;
    2. 将3个运算符插入到每两个数之间;
    3. 计算三个运算符的两边的数,并将数保存用于运算;
    4. 4个数变3个数,3个数变两个数,两个数变1个数;
    5. 注意除号运算。
    
    import random as r
    
    number = [0, 0, 0, 0]
    countTool = ["+", "-", "*", "/"]
    iop = 1
    k = "("
    z = ")"
    
    
    # 计算两个数(param, param1)运算的结果,运算符op
    def count_2_number(param, param1, op):
        if countTool[op] == "+":
            return param + param1
        if countTool[op] == "-":
            return param - param1
        if countTool[op] == "*":
            return param * param1
        if countTool[op] == "/" and param1 != 0 and param % param1 == 0:
            return param / param1
        else:
            return -9999
    
    
    # 获得等于24的表达式 参数(param, param1, param2, param3)
    # 计算4个数的所有得到24的表达式
    def get_expression(param, param1, param2, param3):
        for op1 in range(4):
            front = count_2_number(param, param1, op1)
            for op2 in range(4):
                middle = count_2_number(param1, param2, op2)
                again1 = count_2_number(front, param2, op2)
                again2 = count_2_number(param, middle, op1)
                for op3 in range(4):
                    last = count_2_number(param2, param3, op3)
                    again3 = count_2_number(param1, last, op3)
                    again4 = count_2_number(middle, param3, op2)
    
                    # 5种不同的运算顺序得到的5种结果
                    result1 = count_2_number(again1, param3, op3)
                    result2 = count_2_number(again2, param3, op3)
                    result3 = count_2_number(param, again3, op1)
                    result4 = count_2_number(param, again4, op1)
                    result5 = count_2_number(front, last, op2)
    
                    if result1 == 24:
                        return k + k + str(param) + countTool[op1] + str(param1) + z + countTool[op2] + str(
                            param2) + z + countTool[op3] + str(param3) + "=24"
                    if result2 == 24:
                        return k + str(param) + countTool[op1] + k + str(param1) + countTool[op2] + str(
                            param2) + z + z + countTool[op3] + str(param3) + "=24"
                    if result3 == 24:
                        return str(param) + countTool[op1] + k + str(param1) + countTool[op3] + k + str(
                            param2) + countTool[op3] + str(param3) + z + z + "=24"
                    if result4 == 24:
                        return str(param) + countTool[op1] + k + k + str(param1) + countTool[op2] + str(
                            param2) + z + countTool[op3] + str(param3) + z + "=24"
                    if result5 == 24:
                        return k + str(param) + countTool[op1] + str(param1) + z + countTool[op2] + k + str(
                            param2) + countTool[op3] + str(param3) + z + "=24"
        return "null"
    
    
    # 使用4个嵌套for循环列出排列组合
    def count24():
        haveResult = 0
        for a in range(4):
            for b in range(4):
                if a == b:
                    continue
                for c in range(4):
                    if a == c or b == c:
                        continue
                    for d in range(4):
                        if a == d or b == d or c == d:
                            continue
                        # print(str(number[a]) + "\t"
                        #       + str(number[b]) + "\t"
                        #       + str(number[c]) + "\t"
                        #       + str(number[d]) + "\t")
                        expr = get_expression(number[a], number[b], number[c], number[d])
                        if expr.__eq__("null"):
                            continue
                        else:
                            print(expr)
                            haveResult = 1
        if haveResult == 0:
            print("无解!")
    
    
    # 等待用户输入 给出答案
    def wait_for_input():
        cmdStr = input()
        count24()
    
    
    while iop == 1:
        print("请通过计算获得24:=======================================")
        for i in range(4):
            number[i] = 1 + (r.random() * 10).__int__()
            print(number[i])
        wait_for_input()
    
    

    在这里插入图片描述

    展开全文
  • 24点游戏的递归解法和Python实现 目录24点游戏的递归解法和Python实现什么是24点游戏递归思路递归24点问题的递归思路Python代码实现四则运算下无解的组合总结 什么是24点游戏 还记得小时候拿一副牌玩得24点游戏吗...

    24点游戏的递归解法和Python实现


    什么是24点游戏

    还记得小时候拿一副牌玩得24点游戏吗?

    拿一副牌,抽去大小王后(J,Q,K记为11,12,13;用1代替A),剩下1~13这52张牌。任意抽取4张牌(称为牌组),用加、减、乘、除(可加括号,高级玩家也可用其他运算符号)把牌面上的数算成24。每张牌必须用且只能用一次。如抽出的牌是3、8、8、9,那么算式为(9-8)×8×3=24。

    下面就介绍一种求解24点问题的递归思路以及给出其Python求解代码。


    递归思路

    递归

    递归的思路便是把大的问题变小,每一步将原先要求解的问题分解成与原问题相似的规模较小的问题更小的问题,直至最后达到一个满足退出条件的简单问题,这样再一层层向上返回,便解决了原先的大规模的问题。在代码实现中,程序不断调用自身,每次调用都使问题规模变小,最后达到退出条件一层层返回直至解决原先的问题。

    构成递归需具备的条件:
    1.子问题须与原始问题为同样的事,且更为简单;
    2.不能无限制地调用本身,须有个出口,化简为非递归状况处理。

    理解它的一个非常好的例子便是阶乘。n的阶乘(记为fact(n))定义为:
    n!=i=1ni=n(n1)(n2)...1n!=\prod_{i=1}^{n}i=n*(n-1)*(n-2)...*1
    它可以通过递归方式定义为:
    若n=1 , 则fact(n)=1;
    若n为大于1的整数,则fact(n)=n*fact(n-1)
    这相当于给了一个退出条件(n=1的情况),和一个把问题分解为更小的同类型问题的方法(求n的阶乘变为求n乘上n-1的阶乘)。很容易验证,这样的递归定义和其本身的定义是一致的,而递归定义很容易用通过函数调用自身的程序代码实现。

    24点问题的递归思路

    24点问题也是同理
    用四张牌求出24点也许没那么容易,但如果只有两个数,那么我们可以很容易地通过不同的运算符(例:加减乘除)得到两个数组合之后的结果。因此两个数的24点问题是一目了然的。
    那么三个数呢?对于三个数a,b,c,我们可以从其中任意挑选两个数(三种挑选方式),例如a,b,之后通过加减乘除计算得到a与b组合后的数d(如果只有四则运算,a与b一定时d有a*b,a+b,a-b,b-a,a/b,b/a几种可能,当然除法首先要求分母不为0),那么d确定了之后问题便变成c与d算24点的两数问题,它们是否能得出24是一目了然的。于是对一个个分支(及所有可能的c和d)进行尝试,便能判断三个数能否以及如何得出24点。
    四个数当然也可以以同样的方法变为多个三数问题,进而变成两数问题输出结果。
    当然如果不止四个数也可以以同样的方法一步步使问题变小,直至缩小成两数问题达到递归的返回条件。

    于是我们的算法求解如下:
    1.一个将两个数a,b通过运算组合成新的数的函数f(a,b)
    此函数输入两个数a,b,输出它们四则运算的各种对应解及其运算符。
    例如输入(a,b),输出a+b的结果及加号,a-b的结果及减号…
    2.递归主程序
    输入牌组,判断牌组长度,若为两数问题则通过f(a,b)判断能否算出24点并返回;若牌组长度大于2则任选两个数a,b;调用函数f(a,b),将其输出的数存储在一个新的牌组中(此数所对应的运算符即为当前的解决方案分支),新的牌组长度比原先的长度减一,解这个新的牌组的24点问题。

    函数的Python实现
    1.一个将两个数a,b通过运算组合成新的数的函数f(a,b)
    在Python中可以以一个列表的形式很容易地将输出存储起来,即输入(a,b)两个数,f(a,b)返回[(a+b,’+’),(a-b,’-’),…],这里方括号代表列表,括号代表元祖的数据结构,它将运算结果和其对应的运算符放在一起。运算结果对应的运算符用字符(即’+’,’-’,…)进行输出。
    2.递归主程序
    牌组可用列表来保存,并记录当前列表长度用来判断,用一个全局的数组记录求解过程,即在每一个递归分支中,保存使用过的数,组合成新数的运算符等。

    将牌组记为列表A,全局的数组(当前求解过程)记为temp,初始问题大小记为N,当前问题大小记为n,则主程序可以用一张图加以说明:
    递归主程序

    Python代码实现

    cal24.py中代码如下:

    #交换a与b
    def swap(a,b):
        temp=a
        a=b
        b=temp
        return a,b
    
    
    # +:0, -:1, *:2, /:3
    #in:two number
    #out:a tuple with result and its operator
    def f(a,b):
        
        #让a>=b
        if(a<b):
            a,b=swap(a,b)
            
        res=[]
        res.append((a*b,'*'))
        res.append((a+b,'+'))
        res.append((a-b,'-'))
        if(b!=0):
            res.append((a/b,'/'))
            res.append((b/a,'/'))
        else:
            res.append((0,'/'))
        return res
    
    
    
    #a:list,element is number
    #temp:list,the solution,len=N+1
    #N:dimension of initial problem
    #n:len(a)
    def cal(a,n,temp,N):
        if(n<=2):
            res=f(a[0],a[1])
            for i in res: 
                #例(c,'+') i[0]对应c,i[1]对应'+'
                temp[N+1-n]=(a[0],i[1],a[1],'=',24)
                if(abs(i[0]-24)<=1E-7):
                    temp[0]=True
                    #输出求解过程
                    print(temp[1:]) 
                    break
            return
                
        else:        
            for i in range(0,n):
                #若前面得到了结果则退出分支
                #若注释if,则即使得到结果也会计算其他求解24点的方案
                if(temp[0]==True):
                            break
                for j in range(i+1,n):
                        res=f(a[i],a[j])                    
                        for k in res:
                            temp[N+1-n]=(a[i],k[1],a[j],k[0])
                            #下一步要求解的新数组
                            new_a=[]            
                            for m in range(0,n):
                                if(m!=i and m!=j):
                                    new_a.append(a[m])
                            new_a.append(k[0])
                            #print(new_a,n,temp[0])
                            #input()
                            cal(new_a,n-1,temp,N)
    
    

    在Python shell中进行测试:

    >>> a=[1,5,5,5]
    >>> N=4
    >>> n=4
    >>> temp=N*[0]
    >>> temp[0]=False
    >>> cal(a,n,temp,N)
    [(1, '/', 5, 0.2), (5, '-', 0.2, 4.8), (5, '*', 4.8, '=', 24)]
    

    输出结果意思是1,5,5,5四张牌,用1除以5得到0.2,用5-0.2得到4.8,最后用4.8乘以5可以得到24

    当然将cal函数的else分支的if判断注释掉之后,可以输出一个牌组的多种求解方案:
    Python shell中:

    >>> a=[5,6,9,8]
    >>> N=4
    >>> n=4
    >>> temp=N*[0]
    >>> temp[0]=False
    >>> cal(a,n,temp,N)
    [(5, '-', 9, 4), (8, '-', 4, 4), (6, '*', 4, '=', 24)]
    [(5, '+', 8, 13), (9, '-', 13, 4), (6, '*', 4, '=', 24)]
    [(5, '/', 8, 1.6), (6, '+', 9, 15), (1.6, '*', 15, '=', 24)]
    [(5, '/', 8, 0.625), (6, '+', 9, 15), (0.625, '/', 15, '=', 24)]
    [(6, '+', 9, 15), (5, '/', 8, 1.6), (15, '*', 1.6, '=', 24)]
    [(6, '+', 9, 15), (5, '/', 8, 0.625), (15, '/', 0.625, '=', 24)]
    [(6, '+', 9, 15), (5, '/', 15, 3.0), (8, '*', 3.0, '=', 24)]
    [(6, '+', 9, 15), (5, '/', 15, 0.3333333333333333), (8, '/', 0.3333333333333333, '=', 24)]
    [(6, '+', 9, 15), (8, '*', 15, 120), (5, '/', 120, '=', 24)]
    [(9, '-', 8, 1), (5, '-', 1, 4), (6, '*', 4, '=', 24)]
    

    即牌组[5,6,9,8]有多种解决方案。对于其他牌组,大家可以自行验证。

    四则运算下无解的组合

    最后讨论一下24点游戏在四则运算下无解的牌组

    在cal24.py中定义以下函数:

    #使用此函数时将 输出无解的组合 
    def judge(a):
        temp=(n+1)*[0]
        temp[0]=False
        cal(a,n,temp,N)
        if(temp[0]==True):
            return True
        else:
            return False
    
    def groupOfNoAnswer():
        s=0
        NoAnsGroup=[]
        for i in range(1,14):
            for j in range(i,14):
                for k in range(j,14):
                    for l in range(k,14):
                        a=[i,j,k,l]
                        if(not judge(a)):
                            NoAnsGroup.append(tuple(a))
                            s+=1
        return s,NoAnsGroup
    

    这没什么东西,就是判断是否有解并遍历整个牌组的所有组合。
    Python shell中我们输入

    >>> s,NoAns=groupOfNoAnswer()
    >>> s
    458
    >>> NoAns[1:10]
    [(1, 1, 1, 2), (1, 1, 1, 3), (1, 1, 1, 4), (1, 1, 1, 5), (1, 1, 1, 6), (1, 1, 1, 7), (1, 1, 1, 9), (1, 1, 1, 10), (1, 1, 2, 2)]
    
    

    即在四则运算下共有458种牌组得不到24点的解(当然引入别的运算符如乘方等也许可以得出解,这只需改动f(a,b)函数添加新的运算符即可)


    总结

    本文讨论了24点游戏的递归解法思路和Python实现,并给出了四则运算得不到24解的一些牌的组合。 掌握了这个思路,以后在家无聊和亲朋好友玩这款游戏的时候便绝对不会输了,甚至还可以故意出点带除法的难题来小小地为难一下他们呢!当别人想不出来自己再在他们惊异的眼光中给出答案的时候,会非常有成就感的!(^_^)

    附B站视频链接:
    https://www.bilibili.com/video/BV1Xz4y1Z7yg/

    展开全文
  • 计算24点是一种扑克牌益智游戏,随机抽出4张扑克牌,通过加(+),减(-),乘(*), 除(/)四种运算法则计算得到整数24,本问题中,扑克牌通过如下字符或者字符串表示,其中,小写joker表示小王,大写JOKER表示大王: 3 4...

    首先是规则说明 :

    链接:https://www.nowcoder.com/questionTerminal/7e124483271e4c979a82eb2956544f9d?f=discussion
    来源:牛客网

    计算24点是一种扑克牌益智游戏,随机抽出4张扑克牌,通过加(+),减(-),乘(*),
    除(/)四种运算法则计算得到整数24,本问题中,扑克牌通过如下字符或者字符串表示,其中,小写joker表示小王,大写JOKER表示大王:

       3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
    

    本程序要求实现:输入4张牌,输出一个算式,算式的结果为24点。

    详细说明:

    1.运算只考虑加减乘除运算,没有阶乘等特殊运算符号,友情提醒,整数除法要当心;
    2.牌面2-10对应的权值为2-10, J、Q、K、A权值分别为为11、12、13、1;
    3.输入4张牌为字符串形式,以一个空格隔开,首尾无空格;如果输入的4张牌中包含大小王,则输出字符串“ERROR”,表示无法运算;
    4.输出的算式格式为4张牌通过±/四个运算符相连,中间无空格,4张牌出现顺序任意,只要结果正确;
    5.输出算式的运算顺序从左至右,不包含括号,如1+2+3
    4的结果为24
    6.如果存在多种算式都能计算得出24,只需输出一种即可,如果无法得出24,则输出“NONE”表示无解。

    由以上要求,可以提取出以下几个需求点:

    1.转换特殊字符'J' 'Q' 'K' 'A'为数字
    2.计算结果得到24则输出相应算式
    3.无解则输出'NONE'
    4.'JOKER'及'joker'输出‘ERROR’
    

    为实现运算符号的遍历,这里将运算符号作为字符串处理,通过另一个函数将对应符号转化为相应的算式:

    def cal(num1,num2,index): #index转换为运算符号
    	if index == '+' :
    		result=num1+num2
    	elif index == '*' :
    		result=num1*num2
    	elif index == '-' :
    		result=num1-num2
    		if result < 0 :
    			result=-1
    	elif index == '/' :
    		result=num1/num2
    		if result*num2 != num1 :
    			result=-1
    	return result
    def cal24(count0,count1,count2,count3): #穷尽所有运算方式
    	list_cal=['+','-','*','/']
    	for i in list_cal:
    		result1=cal(count0,count1,i)
    		if result1 == -1 :
    			continue
    		for j in list_cal:
    			result2=cal(result1,count2,j)
    			if result2 == -1 :
    				continue
    			for k in list_cal:
    				result3=cal(result2,count3,k)
    				if result3 == 24 :
    					print(count0,i,count1,j,count2,k,count3,sep='')
    					return result3
    

    其次是计算24点的方式,这里使用穷举法,即暴力遍历所有可能的计算结果,结果为24则输出算式。
    完整代码如下:

    def cal(num1,num2,index): #index转换为运算符号
    	if index == '+' :
    		result=num1+num2
    	elif index == '*' :
    		result=num1*num2
    	elif index == '-' :
    		result=num1-num2
    		if result < 0 :
    			result=-1
    	elif index == '/' :
    		result=num1/num2
    		if result*num2 != num1 :
    			result=-1
    	return result
    def cal24(count0,count1,count2,count3): #穷尽所有运算方式
    	list_cal=['+','-','*','/']
    	for i in list_cal:
    		result1=cal(count0,count1,i)
    		if result1 == -1 :
    			continue
    		for j in list_cal:
    			result2=cal(result1,count2,j)
    			if result2 == -1 :
    				continue
    			for k in list_cal:
    				result3=cal(result2,count3,k)
    				if result3 == 24 :
    					print(count0,i,count1,j,count2,k,count3,sep='')
    					return result3
    def caculate(list) : #穷尽所有组合方式
    	list1,list2,list3=[],[],[]
    	for count0 in list :
    		list1=list.copy()
    		list1.remove(count0)
    		for count1 in list1 :
    			list2=list1.copy()
    			list2.remove(count1)
    			for count2 in list2 :
    				list3=list2.copy()
    				list3.remove(count2)
    				for count3 in list3:
    					result=cal24(count0,count1,count2,count3)
    					if result == 24 :
    						return 0
    	print('NONE')
    inputStr=input()
    str=inputStr.split()
    str1=[]
    #将J、Q、A转换为11、12、13,joker则显示ERROR
    for i in str :
    	if i == 'J' :
    		str1.append(11)
    	elif i == 'Q' :
    		str1.append(12)
    	elif i == 'K' :
    		str1.append(13)
    	elif i == 'A' :
    		str1.append(1)
    	elif i == 'joker' or i == 'JOKER' :
    		print("ERROR")
    		quit()
    	else :
    		str1.append(int(i))
    
    caculate(str1)
    
    展开全文
  • 24点游戏-Python实现

    2011-09-07 21:22:01
    利用加减乘除以及括号将给出的四张牌组成一个值为24的表达式
  • 自己没事干,写着练练手的小程序,程序的逻辑比较简单,看着代码不会很难,有问题的可以私聊我,我也是刚开始学的python,写的不对的,还请多多指教
  • 我们用Python来完成24点游戏的程序设计!!从此站在赌神巅峰 我在拉斯维加斯等你 PS注意:很多人学Python过程中会遇到各种烦恼问题,没有人解答容易放弃。为此小编建了个Python全栈免费答疑.裙 :七衣衣九七七巴而...

空空如也

空空如也

1 2 3 4
收藏数 76
精华内容 30
关键字:

python实现24点游戏

python 订阅