题解 | #四则运算#

#输入有其它括号，换成（）
equation = list(map(str,input().replace('[','(').replace(']',')').replace('{','(').replace('}',')')))
new_equation = []
for i in range(len(equation)):
    if i == 0:
        new_equation.append(equation[i])
    else:
        if equation[i].isdigit():
            if new_equation[-1].isdigit():
                new_equation[-1] += equation[i]
            else:
                new_equation.append(equation[i])
        else:
            new_equation.append(equation[i])
equation = new_equation

#统计多少个括号
brackets = 0
for i in equation:
    if i == "(":
        brackets += 1

#寻找最内层的括号/是里面没有别的括号的括号
def find_inner_bracket(equation):
    bracket_index = []
    for i in range(len(equation)):
        if equation[i] == "(":
            for j in range(i+1, len(equation)):
                if equation[j] == "(":
                    break
                elif equation[j] == ")":
                    if len(bracket_index) == 0:
                        bracket_index.append(i)
                        bracket_index.append(j)
                    break
    return bracket_index

#嵌套的无括号表达式计算
def calculate_without_bracket(sub_s):
    nums = []
    for j in range(len(sub_s)):
        #先读入第一个
        if j == 0:
            if sub_s[j].isdigit():
                nums.append(int(sub_s[j]))
            else:
                continue
        else:
            if sub_s[j-1] == "+":
                nums.append(int(sub_s[j]))
            elif sub_s[j-1] == "-":
                nums.append(-int(sub_s[j]))
            elif sub_s[j-1] == "*":
                nums[-1] = nums[-1] * int(sub_s[j])
            elif sub_s[j-1] == "/":
                nums[-1] = nums[-1] // int(sub_s[j])
    return str(sum(nums))

#对最内层（）内的表达式进行计算
def calculate_with_bracket(bracket_range, equation):
    s_braket = bracket_range
    # for i in range(len(equation)):
    #     if equation[i] == x:
    #         s_braket.append(i)
    #     elif equation[i] == y:
    #         s_braket.append(i)
    if len(s_braket) != 0:
        for i in range(0, len(s_braket), 2):
            #进行括号内计算
            sub_s = equation[s_braket[i]+1: s_braket[i+1]]
            # print(sub_s)
            sub_res = calculate_without_bracket(sub_s)
            #得到结果后删除括号及括号内表达式并插入结果
            del equation[s_braket[i]:s_braket[i+1]+1]
            equation.insert(s_braket[i], sub_res)
    return equation

#计算：共循环括号个数次
for i in range(brackets):
    # print(equation)
    bracket_range = find_inner_bracket(equation)
    # print(bracket_range)
    equation = calculate_with_bracket(bracket_range, equation)

if len(equation) == 1:
    res = equation[0]
    print(res)
else:
    # print(equation)
    res = calculate_without_bracket(equation)
    print(res)



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

本质上也是递归思想，（新人代码写的比较丑见谅）：

A.预处理：

首先把{}和[]都转换成()预处理；

把连续的数字也就是多位数字（大于等于两位的数字）合并成list当中的一项构建新的字符list；

统计括号的个数，通过数有多少个"("，确定循环（递归）次数。

B.正式处理：

在当前递归循环中，寻找list中最内层的括号（即括号内没有其它括号的括号）的起止index，在最左端的优先，每次只处理一个最内层括号内的表达式

计算完成后，删除list中包括该最内层括号以及其起止范围内的表达式对应的字符，将计算结果插入该括号的起点位置，得到要在下一轮中进行计算的新的list

C.结果判定：

if:范例输入的整个表达都是在括号内，则以上计算结果输出的list只有一个字符元素，即结果，转格式输出

else:再进行一次无括号计算，输出结果

整个逻辑感觉可以归纳为更加精简的递归格式，欢迎批评！