python实现算24的算法

1.介绍

  给定4个整数,数字范围在1-13之间,任意使用 + - * / ( ) ,构造出一个表达式,使得最终结果为24,这就是常见的算24的游戏。本文介绍用Python语言实现的两种方式。
2.实现思路

  实现输入4个数字的排列组合,这样等于实现了括号的功能,然后使用+ - * /进行组合计算。
  第一种使用简写的方式,比第二种更好用。
  第二种按一般的实现思路,加有注释,更易看懂。

3.代码实现

3.1 第一种,使用列表的切片操作实现排列组合,使用异常进行下一次循环。

# encoding=utf-8
a = int(input("请输入第1个数字:"))
b = int(input("请输入第2个数字:"))
c = int(input("请输入第3个数字:"))
d = int(input("请输入第4个数字:"))
list1 = [a, b, c, d]
list2 = []
list3 = []
symbols = ["+", "-", "*", "/"]
class FindException(Exception):
    pass
try:
    for i in range(4):
        one = list1[i]
        list2 = list1[0:i] + list1[i + 1:]
        for j in range(3):
            two = list2[j]
            list3 = list2[0:j] + list2[j + 1:]
            for k in range(2):
                three = list3[k]
                four = (list3[0:k] + list3[k + 1:])[0]
                for s1 in symbols:
                    for s2 in symbols:
                        for s3 in symbols:
                            express = "((one {0} two) {1} three) {2} four".format(s1, s2, s3)
                            if eval(express) == 24:
                                print("(({0} {1} {2}) {3} {4}) {5} {6} = 24".format(one, s1, two, s2, three, s3, four))
                                raise FindException
    print("无法算出")
except FindException:
    pass

3.2 第二种,使用itertools模块实现排列组合,使用变量val1,val2等变量存储中间变量,以达到进行下一次循环的效果。

# encoding=utf-8
# 用你熟悉的程序语言实现 算24 的算法
# 已知4个整数,数字范围在1-13之间,求计算方法(限加减乘除,可带括号),可以计算出24
import itertools
import copy
a = int(input("请输入第1个数字:"))
b = int(input("请输入第2个数字:"))
c = int(input("请输入第3个数字:"))
d = int(input("请输入第4个数字:"))
inputList = [a, b, c, d]
listAll = []  # 用来存储这个列表数字的排列组合 [[],[],[],[]......]
listSignIndex = []  # 用来存储输出的运算符号顺序下表 0,1,2,3 对应 + - * /
listSign = []  # 用来存储输出的运算符号 + - * /
listSet = list(itertools.permutations(inputList, 4))  # 无序排列组合
for i in listSet:
    listAll.append(list(i))  # 用list()把元组转换成列表
# 把运算符号的下表转换成对应的符号
def changeIndexToSign():
    for i in listSignIndex:
        if i == 0:
            listSign.append("+")
        elif i == 1:
            listSign.append("-")
        elif i == 2:
            listSign.append("*")
        elif i == 3:
            listSign.append("/")
last = []
def start():
    global last
    while 1:
        for list1 in listAll:
            val = list1[0]
            last = copy.deepcopy(list1)
            for i in range(4):
                if i == 0:
                    val += list1[1]
                elif i == 1:
                    val -= list1[1]
                elif i == 2:
                    val *= list1[1]
                elif i == 3:
                    val /= list1[1]
                val2 = val  # 保存当前的val值 即list1[0] list1[1]运算的值
                for j in range(4):
                    if j == 0:
                        val += list1[2]
                    elif j == 1:
                        val -= list1[2]
                    elif j == 2:
                        val *= list1[2]
                    elif j == 3:
                        val /= list1[2]
                    val1 = val  # 保存当前的val值 即list1[0] list1[1] list[2]运算的值
                    for k in range(4):
                        if k == 0:
                            val += list1[3]
                        elif k == 1:
                            val -= list1[3]
                        elif k == 2:
                            val *= list1[3]
                        elif k == 3:
                            val /= list1[3]
                        if val == 24:
                            listSignIndex.append(i)
                            listSignIndex.append(j)
                            listSignIndex.append(k)
                            changeIndexToSign()
                            return
                        else:
                            val = val1  # 如果这次循环不行,就把那么把val还置为list1[0] list1[1] list[2]运算的值
                    val = val2  # 如果第3值运算完了没有结束,那么把val还置为list1[0] list1[1]运算的值
                val = list1[0]  # 如果第3,第4 值运算完了没有结束,那么把val还置为list1[0]值
start()
listSign.append("");
lastStr = "(("
for i in range(4):
    if i == 1 or i == 2:
        lastStr += str(last[i]) + ")" + listSign[i]
    else:
        lastStr += str(last[i]) + listSign[i]
print(lastStr)
    

原创博文,如有转载,请注清出处哈。

时间: 2024-08-29 05:26:37

python实现算24的算法的相关文章

Python秒算24点,行还是不行?

周末闲来无事,看到隔壁家的老王在和隔壁家的媳妇玩24点,就进屋看了看.发现老王是真不行啊,那不行,这也不行. 就连个24点都玩不过他媳妇,给他媳妇气的,啥都不能满足,这不能,那也不能. 我坐下来和他媳妇玩了两把,那都是无出其右,把把赢! 我要走的时候,他媳妇还挽留我多玩几把,有意思. 为了能让老王在他媳妇面前抬起头来,我决定帮他一把--就用python写了个算24点的玩意,老王对我感激涕零. 什么是24点 我们先来约定下老王和他媳妇玩的24点规则:给定4个任意数字(0-9),然后通过+,-,*,

使用Apriori算法和FP-growth算法进行关联分析(Python版)

===================================================================== <机器学习实战>系列博客是博主阅读<机器学习实战>这本书的笔记也包含一些其他python实现的机器学习算法 算法实现均采用python github 源码同步:https://github.com/Thinkgamer/Machine-Learning-With-Python ==================================

【算法29】速算24

问题描述 题目来源:PAT ds 2-08 给定四个数字a, b, c, d,取值范围为[1, 13]:添加合适的运算符 + , - , * , /, 和括号(, )使得表达式等于24,给出一种可能的表达式方案:如果不可能则返回-1. 例如:输入2, 3, 12, 12, 输出 ((3-2)*12) + 12. 输入5, 5, 5, 2, 输出-1. 问题分析 这个题目似乎没有好的算法,只能暴力搜索. 首先对于所有给个数字进行全排列,总过有$A_4^4 = 24$中排列方式: 然后对于每一种排列

C#实现的算24点游戏的算法的代码

下面资料是关于C#实现的算24点游戏的算法的内容,希望能对码农们有所用处. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; namespace Calc24Points { public class Cell { public enum Type { Number, Signal } public int Number; public ch

北京大学 程序设计与算法(二) 递归 算24

算24 给出4个小于10个正整数,你可以使用加减乘除4种运算以及括号把这4个数连接起来得到一个表达式.现在的问题是,是否存在一种方式使得得到得表达式得结果等于24. 这里加减乘除以及括号的运算结果和运算的优先级跟我们平常的定义一致. 输入 输入数据包括多行,每行给出一组测试数据,包括4个小于10个正整数.最后一组测试数据种包括4个0,表示输入的结束,这组数据不用处理. 输出 对于每一组测试数据,输出一行,如果可以得到24,输出“YES”:否则,输出”no”. 思路: n个数算24,必有两个数先算

Python之路,Day21 - 常用算法学习

Python之路,Day21 - 常用算法学习 本节内容 算法定义 时间复杂度 空间复杂度 常用算法实例 1.算法定义 算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机制.也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出.如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题.不同的算法可能用不同的时间.空间或效率来完成同样的任务.一个算法的优劣可以用空间复杂度与时间复杂度来衡量. 一个算

Problem A: 速算24点

Description 速算24点相信绝大多数人都玩过.就是随机给你四张牌,包括 A(1),2,3,4,5,6,7,8,9,10,J(11),Q(12),K(13).要求只用'+','-','*','/'运算符以及括号改变运算 顺序,使得最终运算结果为24(每张牌必须且仅能用一次).游戏很简单,但遇到无解的情况往往让人很郁闷.你的任务就是针对每一组随机产生的四张牌,判断 是否有解.我们另外规定,整个计算过程中都不能出现小数. Input 输入数据占一行,给定四张牌. Output 如果有解则输出

机器学习经典算法详解及Python实现--K近邻(KNN)算法

(一)KNN依然是一种监督学习算法 KNN(K Nearest Neighbors,K近邻 )算法是机器学习所有算法中理论最简单,最好理解的.KNN是一种基于实例的学习,通过计算新数据与训练数据特征值之间的距离,然后选取K(K>=1)个距离最近的邻居进行分类判断(投票法)或者回归.如果K=1,那么新数据被简单分配给其近邻的类.KNN算法算是监督学习还是无监督学习呢?首先来看一下监督学习和无监督学习的定义.对于监督学习,数据都有明确的label(分类针对离散分布,回归针对连续分布),根据机器学习产

java 24点算法实现

最近闲来无事,突然怀念起小时候和堂兄表姐们经常玩24点游戏,于是就琢磨着是不是开发一个安卓手机版本.然后上网上一搜,发现已经被别人给开发烂了啊.不过这只能说明这个小游戏要想赚广告费很难了,但是拿来锻炼和在妹纸面前装逼还是很有价值的,嘿嘿,想到这里,我最终还是花了3天时间开发了一个小游戏出来. 算法实现 在网上试玩了一个flash的版本,发现还需要实现计算所有正确的结果,然后网上稍微百度了下思路,就开始自己实现了.我开始时大概的思路就是穷举出所有的数字和算式的排列组合,然后一一进行验算,中间碰到两