解24点游戏

24点游戏相信大家比较清楚规则了：给出四个数，运用加减乘除四则运算如何使结果等于24？
1、求解思路
霸王硬上弓，用穷举法。穷举法是最直接暴力的解决方案：已知给出的四个数（如a,b,c,d），搭配任意的三个运算符（如+，*，/）以及两组括号，穷举出所有不同的排列组合方式（如（a/b）+（c*d）），再逐个计算结果是否等于24。
2、具体实现
第一步：产生4个数的所有排列，结果存放在 self.nums 中;
第二步：产生3个运算符的所有组合，随后排列；
operators_combination 存放三个运算符的所有组合（运算符可以重复）。然后对三个运算符的组合进行排列，例如三个运算符分别为（+，-，*），那么对这个组合进行排列后（有顺序先后）的结果有六种：（+，-，*）、（+，*，-）、（-，+，*）（-，*，+）、（*，+，-）、（*，-，+）;
由三个运算符组成的所有的排列组合放在 self.operators_arrangement中。
3、将数字的排列和运算符的排列组合连接起来，组成运算表达式；
这里注意，由4个数字与3个运算符组成的所有表达式都可以在其间穿插两组括号，表示人为设置运算符的优先级，具体的穿插方式有以下五种。当括号也穿插完毕后就可以暴力搜索了，计算结果是否为24。
4、将每一个表达式计算过程中的结果记录下来，便于表达式去重。（其实这里是我瞎捉摸的，对去重有一定效果，但没有完全达到预期效果）
例如表达式（8+4）+（2*6）、（4+8）+（2*6）、（8+4）+（6*2）、（4+8）+（6*2）这四个表达式的计算方法都一样，而我们不希望看到重复的。故思考将每一个表达式的计算过程记录下来，如（8+4）+（2*6）的计算过程用元组（12,12,24）记录，最后根据计算过程是否重复去掉相似的表达式。

import itertools
class Twenty_four_point:
def __init__(self,four_nums_list):
self.nums = map(str,four_nums_list)
self.operators = ['+','-','*','/']
self.result_step = []
def Combinations_and_arrangements(self):
self.nums_arrangement = itertools.permutations(self.nums)
operators_combination = itertools.combinations_with_replacement(self.operators, 3)
operators_arrangement = list()
for item in operators_combination:
for item1 in itertools.permutations(item):
operators_arrangement.append(item1)
self.operators_arrangement= list(set(operators_arrangement))
self.expressions_lst = list()
for nums in self.nums_arrangement:
for operators in self.operators_arrangement:
combination1 = '(' + nums[0] + operators[0] + nums[1] + ')' + operators[1] + '(' + nums[2] + operators[2] + nums[3] + ')'
combination2 = '((' + nums[0] + operators[0] + nums[1] + ')' + operators[1] + nums[2] + ')' + operators[2] + nums[3]
combination3 = '(' + nums[0] + operators[0] + '(' + nums[1] + operators[1] + nums[2] + '))' + operators[2] + nums[3]
combination4 = nums[0] + operators[0] + '((' + nums[1] + operators[1] + nums[2] + ')' + operators[2] + nums[3] + ')'
combination5= nums[0] + operators[0] + '(' + nums[1] + operators[1] + '(' + nums[2] + operators[2] + nums[3] + '))'
self.expressions_lst.extend([combination1,combination2,combination3,combination4,combination5])
def Calculate_result(self,expression):
brackets_index = [i for (i,j) in enumerate(expression) if j in ['(',')']]
try:
if brackets_index == [0, 4, 6, 10]:
self.result_step.append((expression,(eval(expression[1:4]),eval(expression[7:10]),eval(expression))))
elif brackets_index == [0, 1, 5, 8]:
self.result_step.append((expression,(eval(expression[2:5]),eval(expression[0:9]),eval(expression))))
elif brackets_index == [0, 3, 7, 8]:
self.result_step.append((expression,(eval(expression[4:7]),eval(expression[0:9]),eval(expression))))
elif brackets_index == [2, 3, 7, 10]:
self.result_step.append((expression,(eval(expression[4:7]),eval(expression[3:10]),eval(expression))))
elif brackets_index == [2, 5, 9, 10]:
self.result_step.append((expression,(eval(expression[6:9]),eval(expression[3:10]),eval(expression))))
except ZeroDivisionError:
pass
def Filtrate_results(self):
self.valid_result = [(i,j) for i,j in self.result_step if round(j[2],1) == 24.0]
self.filtrated_result = []
temp_lst = []
for (i,j) in self.valid_result:
if j not in temp_lst:
temp_lst.append(j)
self.filtrated_result.append(i)
else:
print('')
if __name__ == '__main__':
input_nums = [1,4,5,6]
problem = Twenty_four_point(input_nums)
problem.Combinations_and_arrangements()
for item in problem.expressions_lst:
problem.Calculate_result(item)
problem.Filtrate_results()
if len(problem.filtrated_result) == 0:
print('Sorry,this problem has no solution!')
else:
print('='*30)
print('The four input numbers are:{}'.format(input_nums))
print('Solutions can be:')
for solution in problem.filtrated_result:
print('
' + solution[:])
print('='*30)
print('')

5、运行结果

==============================
The four input numbers are:[1, 4, 5, 6]
Solutions can be:
4/(1-(5/6))
6/((5/4)-1)
==============================

以上就是整个代码，由于水平确实有限，就不花精力简化代码和优化结果了。自娱自乐一下就好，哈哈O(∩_∩)O~

最后

以上就是跳跃手套为你收集整理的解24点游戏的全部内容，希望文章能够帮你解决解24点游戏所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。