【python】 递归 - 牛客网 HJ50 四则运算

描述

输入一个表达式（用字符串表示），求这个表达式的值。
保证字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。且表达式一定合法。

数据范围：表达式计算结果和过程中满足 ∣val∣≤1000 ∣val∣≤1000 ，字符串长度满足 1≤n≤1000 1≤n≤1000

输入描述：
输入一个算术表达式
输出描述：
得到计算结果

示例1
输入：
3+2*{1+2*[-4/(8-6)+7]}
输出：
25

理解

首先，需要知道，各种括号其实都可以换成一种括号。
然后，分析简单化的问题：当没有括号而只有加减乘除时，该如何实现？
此时可以写出一个简单化的代码，针对没有括号的用例有正确的输出。这里需要利用栈，大致思想就是遇到加减法时，对前面部分进行运算，遇到乘除时，把运算符及数据入栈。
然后，问题再升级为有括号的情况，其实一个括号里面是一个数，其运算结果也可以用刚刚那个简单化的算法得出，这样就有了最终代码：

代码

import re
def computeExpression(exp_str):
    exp_result = 0
    data_arr = []
    ope_arr = ["+"]
    while(exp_str and exp_str[0] != ")"):
        if(exp_str[0] == "("):
            exp_str = exp_str[1:]
            data,exp_str = computeExpression(exp_str)
            data_arr.append(data)
        else:
            fd = re.match('\w+',exp_str)
            if(not fd):
                operator = exp_str[0]
                exp_str = exp_str[1:]
                if(operator == "+" or operator == "-"):
                    if(data_arr):
                        temp_value = data_arr.pop()
                        while(ope_arr):
                            temp_operator = ope_arr.pop()
                            if(temp_operator == "+"): 
                                break
                            elif(temp_operator == "-"):
                                temp_value *= -1
                                break
                            elif(temp_operator == "*"):
                                temp_value *= data_arr.pop()
                            else:
                                temp_value = int(data_arr.pop() / temp_value)
                        exp_result += temp_value
                ope_arr.append(operator)
            else:
                data = fd.group()
                data_arr.append(int(data))
                exp_str = exp_str[len(data):]
    return exp_result,exp_str[1:]


expression_str = input()
expression_str = expression_str.replace(")","+)") + "+"

compute_result,str_ = computeExpression(expression_str)
print(compute_result)

利用解释器本身特性的暴力解法

s=input().replace('{', '(').replace("}",")").replace("[","(").replace("]",")")
print(int(eval(s)))

经典栈解法

import re

# 经典栈非递归
def computeCompression(com_str):
    fig_arr = []
    ope_arr = []
    reverse_flag = False
    while(com_str):
        fd = re.match('\w+',com_str)
        if(fd):
            fig = fd.group()
            fig_arr.append(int(fig))
            com_str = com_str[len(fig):]
        else:
            ope = com_str[0]
            com_str = com_str[1:]
            if(ope == "+" or ope == "-" or ope == ")"):
                while(ope_arr):
                    temp_ope = ope_arr.pop()
                    if(temp_ope == "("):
                        if(ope != ")"): ope_arr.append(temp_ope)
                        break
                    fig2 = fig_arr.pop()
                    fig1 = fig_arr.pop()
                    temp_fig = baiscCompute(fig1,fig2,temp_ope)
                    if(reverse_flag):
                        fig_arr.append(-temp_fig)
                        reverse_flag = False
                    else:
                        fig_arr.append(temp_fig)
                if(ope != ")"): ope_arr.append(ope)
            else:
                if(com_str[0] == "-"):  # 括号后跟负号
                    reverse_flag = True
                    com_str = com_str[1:]
                ope_arr.append(ope)
    return fig_arr[0]

def baiscCompute(fig1,fig2,ope):
    if(ope == "*"): return fig1*fig2
    if(ope == "/"): return int(fig1/fig2)
    if(ope == "+"): return fig1+fig2
    if(ope == "-"): return fig1-fig2

compression_str = input().replace("{","(").replace("[","(").replace("}",")").replace("]",")") + "+"

compute_result = computeCompression(compression_str)
print(compute_result)