用python写了一个24点小游戏（用了枚举算法思想）

大家看完以后可以自己再敲一下代码，才能更熟练的掌握python使用

如果觉得不错的话点一个免费的赞吧！！！！！感谢！！！！

枚举算法是一种基础的搜索算法，它通过遍历问题的所有可能情况来寻找解或进行计算。其核心思想是枚举所有的可能。在使用枚举算法时，需要满足两个条件：可预先确定候选答案的数量；候选答案的范围在求解之前必须有一个确定的集合。该算法通常适用于问题的解空间相对较小、可以通过遍历全部情况来解决的情况。具体步骤包括确定问题的解空间，即确定需要枚举的所有可能情况。

1.先介绍一下24点游戏的玩法：

1. 玩家需要使用加、减、乘、除四则运算，将4张扑克牌上的数字通过运算得出24。
2. 每张牌必须使用一次且只能使用一次，不限定数字的顺序。
3. 可以使用括号来改变运算顺序，从而使得计算结果为24。
4. 当玩家得出一个能够计算出24的表达式时，该玩家获胜。

例如，如果4张牌分别是5、5、5、1，那么可以通过(5-1/5)*5的运算得出24。

2.第一步我们要随机随机生成四个1-13 的数：

代码如下：

#24点游戏 导入必要的模块
import random
import itertools
#定义一个主函数
class  Solvre24():
    def __init__(self):
        self.numberlist=[random.randint(1,13) for item in range(4)]

3. 然后我们吧所有数字排列的所有可能全部列出来：

  self.nlist = []
        [self.nlist.append(item) for item in list(itertools.permutations(self.numberlist)) if item not in self.nlist]
        self.operate=["+","-","*","/"]
        self.opreatelist=list(itertools.product(self.operate,repeat=3))

4. 然后将数学运算的的优先级列出来：

对于四个数字进行优先运算可能出现五种运算顺序是因为加法、减法和乘法满足结合律和交换律，而除法则不满足。因此，在考虑四则运算时，除法可能会受到前面运算的影响，导致不同的顺序产生不同的结果。

让我们以数字 a、b、c 和 d 为例进行说明：

1. (((a op1 b) op2 c) op3 d)
2. ((a op1 b) op2 (c op3 d))
3. ((a op1 (b op2 c)) op3 d)
4. (a op1 ((b op2 c) op3 d))
5. (a op1 (b op2 (c op3 d))) 

然后我们有所有可能的排列的数字 和 运算符 一个一个放在对应位置上

    def solve(self):
        print(len(self.opreatelist)*len(self.nlist))
        print(self.opreatelist)


        solvelist0=['('+str(num[0])+sign[0]+str(num[1])+')'+sign[1]+'('+str(num[2])+sign[2]+str(num[3])+')' for num in self.nlist for sign in self.opreatelist]
        solvelist1=['(({}{}{}){}{}){}{}'.format( num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelist2=['{}{}({}{}({}{}{}))'.format( num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelist3=['({}{}({}{}{}){}{})'.format( num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelist4=['({}{}(({}{}{}){}{})'.format( num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelistall=[solvelist0,solvelist1,solvelist2,solvelist3,solvelist4]
        daan=[]
        for item in solvelistall:
            for i in item:
                try :
                    if eval(i)==24:
                        daan.append(i)

                except :pass
        print(daan )

5.然后把每种情况计算一下与 24进行判断 最后得出结果打印daan列表

6.下面是整个代码：

import random
import itertools
"""
random.randint(1, 13)：这个函数用于生成一个指定范围内的随机整数，范围是从1到13。

itertools.permutations()：这个函数用于生成给定列表的所有排列组合。它接受一个可迭代对象作为参数，并返回一个迭代器，产生这个可迭代对象的所有排列组合。

itertools.product()：这个函数用于生成给定列表的笛卡尔积。product() 接受多个可迭代对象作为参数，并返回一个迭代器，产生这些可迭代对象的笛卡尔积。

eval()：这个函数用于执行存储在字符串中的 Python 表达式。它会将字符串当作有效的表达式进行计算，并返回计算结果。

列表解析 [expression for item in iterable if condition]：这种构造方式是列表解析的一种形式，在一个可迭代对象上进行迭代并生成一个新的列表。在给定条件为真的情况下，它会将表达式应用于迭代对象中的每个元素，并将结果放入一个新列表中。

try-except 块：这是 Python 中的异常处理机制。try 语句用来执行可能出现错误的代码块，except 语句用来处理可能发生的异常。在这个代码中，try-except 用来捕获在计算表达式时可能出现的错误，例如除以零等。如果计算出错，程序会继续执行而不会中断。

"""

class Solve24():
    def __init__(self):
        # 生成四个随机数字
        self.numberlist = [random.randint(1, 13) for item in range(4)]
        self.nlist = []
        # 生成所有四个数字的排列组合
        [self.nlist.append(item) for item in list(itertools.permutations(self.numberlist)) if item not in self.nlist]
        # 定义四则运算符
        self.operate = ["+", "-", "*", "/"]
        # 生成所有四则运算符的排列组合
        self.opreatelist = list(itertools.product(self.operate, repeat=3))

    def solve(self):
        # 计算可能的表达式总数
        print(len(self.opreatelist) * len(self.nlist))
        # 打印所有运算符的组合
        print(self.opreatelist)

        # 生成五种不同括号排列的表达式列表
        solvelist0 = ['('+str(num[0])+sign[0]+str(num[1])+')'+sign[1]+'('+str(num[2])+sign[2]+str(num[3])+')' for num in self.nlist for sign in self.opreatelist]
        solvelist1 = ['(({}{}{}){}{}){}{}'.format(num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelist2 = ['{}{}({}{}({}{}{}))'.format(num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelist3 = ['({}{}({}{}{}){}{})'.format(num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelist4 = ['({}{}(({}{}{}){}{})'.format(num[0], sign[0], num[1], sign[1], num[2], sign[2], num[3]) for num in self.nlist for sign in self.opreatelist]
        solvelistall = [solvelist0, solvelist1, solvelist2, solvelist3, solvelist4]

        daan = []  # 用于存储结果为24的表达式
        for item in solvelistall:
            for i in item:
                try:
                    if eval(i) == 24:  # 尝试计算表达式结果是否为24
                        daan.append(i)  # 如果结果为24，则将表达式加入答案列表
                except:
                    pass  # 如果计算表达式时出现错误（比如除以0），则忽略这个错误

        print(daan)  # 打印所有结果为24的表达式

so = Solve24()
so.solve()