python 超硬核--递归思想解决--24点问题！！！

最新推荐文章于 2022-12-22 21:34:39 发布
最新推荐文章于 2022-12-22 21:34:39 发布
阅读量731 收藏 2
点赞数
分类专栏： Python
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_38973721/article/details/106579040
版权

问题
随意给出四个数字，通过加减乘除四则运算，可以得出24。

算法解决思路：
假设ABCD四个数字

  1. BCD三个数字进行四则运算得到E，然后A与E进行四则运算
  2. AB两个数字进行四则运算的得到E，CD两个数字进行四则运算得到F，然后E和F进行四则运行
  3. ABC三个数字进行四则运算得到E，然后E与D进行四则运算
  4. 判断以上情况得到的结果是否等于24，如果等于，则打印，否则不打印
  1. 随机生产四个数字
#----------------------------------------------------------------------
def get_numbers(num,min_value,max_value):
    """"""
    return list(np.random.randint(min_value,max_value+1,[num]))

返回的结果：

[12, 6, 3, 11]
  1. 对获得的列表进行数据处理
#----------------------------------------------------------------------
def get_2_sets(numbers):
    """"""
    result = []
    for i, num in enumerate(numbers):
        set1 = [num]
        set2 = numbers.copy()
        del set2[i]
        result.append((set1,set2))
    
    if len(numbers) < 4:
        return result
    
    if len(numbers) > 4:
        return Exception(len(numbers))
    
    for i , num in enumerate(numbers):
        for j in range(i+1,len(numbers)):
            set1 = [numbers[i],numbers[j]]
            set2 = numbers.copy()
            del set2[j]
            del set2[i]
            result.append((set1,set2))
    return result

返回的result结果如下：

[([12], [6, 3, 11]), 
([6], [12, 3, 11]), 
([3], [12, 6, 11]), 
([11], [12, 6, 3]), 
([12, 6], [3, 11]), 
([12, 3], [6, 11]), 
([12, 11], [6, 3]), 
([6, 3], [12, 11]), 
([6, 11], [12, 3]), 
([3, 11], [12, 6])]
  1. 对获得的列表进行四则运算
#----------------------------------------------------------------------
def make_result(numbers):
    """"""
    if len(numbers) == 1:
        return [(numbers[0], str(numbers[0]))]
    
    result = []
    for set1,set2 in get_2_sets(numbers):
        result1 = make_result(set1)
        result2 = make_result(set2)
        for value1 , s1 in result1:
            for value2, s2 in result2:
                result.append((value1+value2,f"({s1})+({s2})"))
                result.append((value1*value2,f"({s1})*({s2})"))
                result.append((value1-value2,f"({s1})-({s2})"))
                if value2 != 0:
                    result.append((value1 / value2,f"({s1})/({s2})"))
                result.append((value2-value1,f"({s2})-({s1})"))
                if value1 != 0:
                    result.append((value2 / value1 , f"({s2})/({s1})"))
    return result

运行结果如下：

(12)+((6)+((3)+(11)))
(12)*((6)+((3)+(11)))
(12)-((6)+((3)+(11)))
(12)/((6)+((3)+(11)))
((6)+((3)+(11)))-(12)
((6)+((3)+(11)))/(12)
(12)+((6)*((3)+(11)))
(12)*((6)*((3)+(11)))
(12)-((6)*((3)+(11)))
(12)/((6)*((3)+(11)))
((6)*((3)+(11)))-(12)
((6)*((3)+(11)))/(12)
(12)+((6)-((3)+(11)))
(12)*((6)-((3)+(11)))
(12)-((6)-((3)+(11)))
(12)/((6)-((3)+(11)))
((6)-((3)+(11)))-(12)
((6)-((3)+(11)))/(12)
(12)+((6)/((3)+(11)))
(12)*((6)/((3)+(11)))
(12)-((6)/((3)+(11)))
(12)/((6)/((3)+(11)))
((6)/((3)+(11)))-(12)
((6)/((3)+(11)))/(12)
(12)+(((3)+(11))-(6))
(12)*(((3)+(11))-(6))
(12)-(((3)+(11))-(6))
(12)/(((3)+(11))-(6))
(((3)+(11))-(6))-(12)
(((3)+(11))-(6))/(12)
(12)+(((3)+(11))/(6))
(12)*(((3)+(11))/(6))
(12)-(((3)+(11))/(6))
(12)/(((3)+(11))/(6))
(((3)+(11))/(6))-(12)
(((3)+(11))/(6))/(12)
(12)+((6)+((3)*(11)))
(12)*((6)+((3)*(11)))
(12)-((6)+((3)*(11)))
(12)/((6)+((3)*(11)))
((6)+((3)*(11)))-(12)
((6)+((3)*(11)))/(12)
(12)+((6)*((3)*(11)))
(12)*((6)*((3)*(11)))
(12)-((6)*((3)*(11)))
(12)/((6)*((3)*(11)))
((6)*((3)*(11)))-(12)
((6)*((3)*(11)))/(12)
(12)+((6)-((3)*(11)))
(12)*((6)-((3)*(11)))
(12)-((6)-((3)*(11)))
(12)/((6)-((3)*(11)))
((6)-((3)*(11)))-(12)
((6)-((3)*(11)))/(12)
(12)+((6)/((3)*(11)))
(12)*((6)/((3)*(11)))
(12)-((6)/((3)*(11)))
(12)/((6)/((3)*(11)))
((6)/((3)*(11)))-(12)
((6)/((3)*(11)))/(12)
(12)+(((3)*(11))-(6))
(12)*(((3)*(11))-(6))
(12)-(((3)*(11))-(6))
(12)/(((3)*(11))-(6))
(((3)*(11))-(6))-(12)
(((3)*(11))-(6))/(12)
(12)+(((3)*(11))/(6))
(12)*(((3)*(11))/(6))
(12)-(((3)*(11))/(6))
(12)/(((3)*(11))/(6))
(((3)*(11))/(6))-(12)
(((3)*(11))/(6))/(12)
(12)+((6)+((3)-(11)))
(12)*((6)+((3)-(11)))
(12)-((6)+((3)-(11)))
(12)/((6)+((3)-(11)))
((6)+((3)-(11)))-(12)
((6)+((3)-(11)))/(12)
(12)+((6)*((3)-(11)))
(12)*((6)*((3)-(11)))
(12)-((6)*((3)-(11)))
(12)/((6)*((3)-(11)))
((6)*((3)-(11)))-(12)
((6)*((3)-(11)))/(12)
(12)+((6)-((3)-(11)))
(12)*((6)-((3)-(11)))
(12)-((6)-((3)-(11)))
(12)/((6)-((3)-(11)))
((6)-((3)-(11)))-(12)
((6)-((3)-(11)))/(12)
(12)+((6)/((3)-(11)))
(12)*((6)/((3)-(11)))
(12)-((6)/((3)-(11)))
(12)/((6)/((3)-(11)))
((6)/((3)-(11)))-(12)
((6)/((3)-(11)))/(12)
(12)+(((3)-(11))-(6))
(12)*(((3)-(11))-(6))
(12)-(((3)-(11))-(6))
(12)/(((3)-(11))-(6))
(((3)-(11))-(6))-(12)
(((3)-(11))-(6))/(12)
(12)+(((3)-(11))/(6))
(12)*(((3)-(11))/(6))
(12)-(((3)-(11))/(6))
(12)/(((3)-(11))/(6))
(((3)-(11))/(6))-(12)
(((3)-(11))/(6))/(12)
(12)+((6)+((3)/(11)))
... ...
# 此处省略10368行
  1. 判断运算的结果是否是24
def make_24(numbers):
    """"""
    res = []
    count = 0
    for value,s in make_result(numbers):
        print(s)
        count += 1
        if value == 24:
            res.append(s)
    print(count)
    return res

运行结果为：

answers=['(12)*(((11)-(3))-(6))', '(12)*(((11)-(3))-(6))', '(12)*(((11)-(6))-(3))', '(12)*(((11)-(6))-(3))', '(12)*((11)-((6)+(3)))', '(12)*((11)-((3)+(6)))', '(6)*((12)+((3)-(11)))', '(6)*((12)-((11)-(3)))', '(6)*((12)-((11)-(3)))', '(6)*((12)+((3)-(11)))', '(6)*((3)+((12)-(11)))', '(6)*((3)-((11)-(12)))', '(6)*((3)-((11)-(12)))', '(6)*((3)+((12)-(11)))', '(6)*(((12)+(3))-(11))', '(6)*(((3)+(12))-(11))']

整体代码如下：

#-*- coding:utf-8 -*-
import numpy as np

#----------------------------------------------------------------------
def get_2_sets(numbers):
    result = []
    for i, num in enumerate(numbers):
        set1 = [num]
        set2 = numbers.copy()
        del set2[i]
        result.append((set1,set2))
    
    if len(numbers) < 4:
        return result
    
    if len(numbers) > 4:
        return Exception(len(numbers))
    
    for i , num in enumerate(numbers):
        for j in range(i+1,len(numbers)):
            set1 = [numbers[i],numbers[j]]
            set2 = numbers.copy()
            del set2[j]
            del set2[i]
            result.append((set1,set2))
    return result
    
#----------------------------------------------------------------------
def make_result(numbers):
    if len(numbers) == 1:
        return [(numbers[0], str(numbers[0]))]
    
    result = []
    for set1,set2 in get_2_sets(numbers):
        result1 = make_result(set1)
        result2 = make_result(set2)
        for value1 , s1 in result1:
            for value2, s2 in result2:
                result.append((value1+value2,f"({s1})+({s2})"))
                result.append((value1*value2,f"({s1})*({s2})"))
                result.append((value1-value2,f"({s1})-({s2})"))
                if value2 != 0:
                    result.append((value1 / value2,f"({s1})/({s2})"))
                result.append((value2-value1,f"({s2})-({s1})"))
                if value1 != 0:
                    result.append((value2 / value1 , f"({s2})/({s1})"))
    return result             
    
#----------------------------------------------------------------------
def make_24(numbers):
    res = []
    count = 0
    for value,s in make_result(numbers):
        print(s)
        count += 1
        if value == 24:
            res.append(s)
    return res
    
#----------------------------------------------------------------------
def get_numbers(num,min_value,max_value):
    """"""
    return list(np.random.randint(min_value,max_value+1,[num]))

    
if __name__ == "__main__":
    numbers = get_numbers(4,1,13)
    print(numbers)
    answers = make_24(numbers)
    print(f"answers={answers}")
小鹏AI
关注
专栏目录
24点游戏的递归解法和Python实现
weixin_43700732的博客
10-08 2826
24点游戏的递归解法和Python实现 目录24点游戏的递归解法和Python实现什么是24点游戏递归思路递归24点问题的递归思路Python代码实现四则运算下无解的组合总结 什么是24点游戏 还记得小时候拿一副牌玩得24点游戏吗？ 拿一副牌，抽去大小王后(J,Q,K记为11,12,13；用1代替A)，剩下1～13这52张牌。任意抽取4张牌(称为牌组)，用加、减、乘、除(可加括号，高级玩家也可用其他运算符号)把牌面上的数算成24。每张牌必须用且只能用一次。如抽出的牌是3、8、8、9，那么算式为(9-8)
Python---递归函数实现阶乘
qq_44176343的博客
07-15 4921
文章目录1、什么是递归函数？2、递归函数示例-实现 1、什么是递归函数？ 什么是递归函数：递归函数就是在一个函数体内调用该函数本身，这个函数称为递归函数。 递归函数的组成部分：递归调用与递归终止条件。 递归函数的调用过程： 1.每递归调用一次函数，都会在栈内分配一个栈帧。 2.每次执行完一次函数，都会释放相应的空间。 递归的优缺点： 缺点：占用内存多，效率低下。 优点：思路和代码简单。 2、递归函数示例-实现 1、递归函数：使用递归来计算阶乘。 6！ = 6 * 5 * 4 * 3 * 2 *1 代码：
Python计算24点：递归程序设计艺术(9)
方老师的博客
07-22 625
给定4个1～13之间的数，用任意多的加减乘除和括号计算这4个数，使得最终结果是24，这就是著名的24点问题。本节课的目的是编写一个程序，能够用给定的4个数凑出24。也就是说，让电脑而不是人脑计算24点。这一题看起来难度很大，但是只要坚持递归三步曲问题一样可以解决。 首先把原问题分解为两个子问题：1) 4个数能凑出哪些表达式，以及每个表达式的值；2)上述表达式中哪些的值是24。第二个问题好解决。第一个问题可以用一个递归程序解决，首先明确第一个问题的参数是nums，表示当前可以使用的数的列表。注意这里只...
Python 求解24点
weixin_34363171的博客
05-17 257
2019独角兽企业重金招聘Python工程师标准>>> ...
【机试题(实现语言：python3)】24点游戏算法----递归
qq_35061334的博客
05-23 493
题目描述 问题描述：给出4个1-10的数字，通过加减乘除，得到数字为24就算胜利 输入： 4个1-10的数字。[数字允许重复，但每个数字仅允许使用一次，测试用例保证无异常数字。 输出： true or false 本题含有多组样例输入。 输入描述: 输入4个int整数 输出描述: 返回能否得到24点，能输出true，不能输出false 示例1 输入 7 2 1 10 输出 true 代码实现如下 import sys def func(nums, tar): if len(nums) =
[python]【练手向】24点问题的一个Python解
u013592711的专栏
03-26 831
class mNum: def __init__(self,num): self.num = float(num) self.str = "%s" % num def eval(self,second,opera): ret = mNum(0) if opera == "+": ret.num = self.num + second.num elif opera =
Python递归穷举解决24点问题
aitizhiren的博客
06-04 681
问题描述：在一副扑克牌去掉大小王后，随机抽取4张牌，对其进行四则运算（可带括号），寻找结果等于24的解法 解决方案：对牌的顺序、括号位置、可能的运算符穷举，直到找到解法 知识点：递归思想，python中排列组合、求笛卡尔积的函数 局限性：指数级时间复杂度，仅适合少量数据(牌的张数较少) 代码(python 3.7) import random import itertools # 假定仅4张牌 def find24(cards): # 可用的运算符 ops = ['+', '-', '
Python-用于使用深度优先搜索和递归回溯算法生成和解决随机可解迷宫的Python脚本
08-11
用于使用深度优先搜索和递归回溯算法生成随机可解迷宫的Python脚本。 该代码还实现了用于解决生成的迷宫的递归回溯寻路算法。 这里是一个生成的迷宫及其计算解决方案的例子。
python练习------使用递归函数实现阶乘
ly_qiu的博客
07-29 2787
递归函数：一个函数在内部调用自己本身（自己调用自己），考虑什么时候跳出阶乘 练习：计算阶乘 # 1!=1 # 2!=2*1 # 3!=3*2! # .... # n!=n*(n-1)! # def factorial(n): # if n <= 1: # return 1 函数遇到return结束执行 # else: # return n * factorial(n-1) # # result = factorial(8) # print(resu
Python 递归 深入理解递归 Python递归剖析，绝对让你看懂！
热门推荐
storyfull
10-21 5万+
递归再特定的场景下，非常实用，巧妙的递归设计能解决很多问题，文章主要列出了递归的各种思想和丰富的使用案例！
递归解决24点程序及深入分析
06-29
这是我在学习计算智能这门课时所完成的试验报告，使用递归解决了24点问题并作出了深入的分析。程序均通过编译并可以得到结果。
python基于右递归解决八皇后问题的方法
12-25
本文实例讲述了python基于右递归解决八皇后问题的方法。分享给大家供大家参考。具体分析如下： 凡是线性回溯都可以归结为右递归的形式，也即是二叉树，因此对于只要求一个解的问题，采用右递归实现的程序要比回溯法...
Point 24点计算Python编程思路(二)递归思路
liu_xiang的博客
11-17 509
24点计算编程思路 二、寻求全部解的递归算法 分治法是一种循环迭代的算法，也可以看成一种递归思路。 Python 递归主程序 recurs24.py 递归的思路逐步降维思路，在代码实现中，程序不断调用自身，每次调用都使大问题规模变小，最后达到退出条件（可以计算的条件）一层层返回直至解决原先的问题。 递归算法达到降维作用 采用降低维度的算法，即把多维问题降低到二维甚至一维来解决。 比如，给定四个数字 [a, b, c, d]，这是一个四维问题，我们首先要将其转换为二维问题。 (1) 任取四个数中的两个，有C(
递归算24点
yzs981130的博客
12-20 3902
使用递归算24点 #include #include using namespace std; double a[4]; const double eps = 1e-3; int result(int n) { int i, j; double p, q; if (n == 1) { if (fabs(a[0] - 24) < eps)
python24点问题_python：基于二叉树速解凑24点问题
weixin_39682897的博客
12-10 94
# 暨南大学 王杰安import itertoolsdef add(a, b):return a+bdef sub(a, b):return a-bdef pro(a, b):return a*bdef div(a, b):return a/bdef wcd_find_tree(tree):root = []; root_leaf = [] deep = max(map(lambda x: ...
递归函数解决24点
最新发布
weixin_35749796的博客
12-22 254
24 点是一个数学问题，游戏规则是给定 4 个数字，通过使用加、减、乘、除(但不能使用括号)来计算出 24。 递归函数是一种解决问题的方法，它在解决问题的过程中，会不断地调用自身来解决更小的子问题。 在解决 24 点问题时，可以使用递归函数的方法。首先，将 4 个数字放入一个数组中，然后对数组中的每一个数字进行运算(加、减、乘、除)，得到一个新的数字。然后，将新的数字放回数组中，并递归调用函数本身...
递归-24点
Case
03-07 2641
最近写d一个24点算法，不过同时可以实现输入一组数字，按所要求的答案，返回输出一条算术式子，在算法中主要利用了递归，逐层计算。例子：((((3*3)+4)/3)*6) = 26；下面为代码： cpp文件：#include"alg_Ans.h"void main(){ vectorInput; string Exp; int Con_record = 0; int Ans = 24;
python 实现经典24点
qq_37286849的博客
07-24 9701
一，概述 算24点：任意给定四个整数，用加、减、乘、除以及适当的括号连接，无论顺序，使计算结果为24，也可能根本就无解。如何用程序简单实现找到算式是程序初学者关注的问题，百度上可以搜到许多这样的文章，有递归法、回溯法、穷举法。但穷举法最为简单、易于理解。 二，算法 穷举法就是把四个数字的所有运算式进行尝试计算，要设法把所有排列一点不差地穷举出， 一、是四个整数位置的排列，用0,1,2,3表...
递归——计算24点
HowCowBear的博客
10-12 489
递归计算24点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鹏AI

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值