表达式求值

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 返回表达式的值
# @param s string字符串 待计算的表达式
# @return int整型
#
class Solution:
    def solve(self , s: str) -> int:
        # write code here
        # 实施运算的操作函数
        def apply_op(a,b,op):
            if op == "+":return a+b
            if op == "-":return a-b
            if op == "*":return a*b
        # 运算符优先级赋值
        def procal(op):
            if op in ("+","-"):return 1
            if op == "*": return 2
            return 0
        # 设置两个栈，分别为数值栈和运算符栈
        num_stack = []
        op_stack = []
        # 用于累积总处理的字符数值，包括数字和运算符
        i = 0
        while i < len(s):
            # 判断该字符是否为数字
            if s[i].isdigit():
                num = 0
                # 对于数字超过1位数的计算数进行累加起来，整合成真正需要计算的数
                while i < len(s) and s[i].isdigit():
                    num = num *10 + int(s[i])
                    i += 1
                # 将需要计算的数字添加到数值栈
                num_stack.append(num)
            # 对于优先级最高的括号，进行匹配和优先运算
            elif s[i] == "(":
                op_stack.append(s[i])
                i += 1
            elif s[i] == ")":
                while op_stack[-1] != "(":
                    num1 = int(num_stack.pop())
                    num2 = num_stack.pop()
                    op = op_stack.pop()
                    num_stack.append(apply_op(num2,num1,op))
                op_stack.pop()
                i += 1
            # 按照优先级，优先级更高的先进行运算
            elif s[i] in ("+","-","*"):
                while (op_stack and procal(op_stack[-1])>=procal(s[i])):
                    num1 = num_stack.pop()
                    num2 = num_stack.pop()
                    op = op_stack.pop()
                    num_stack.append(apply_op(num2,num1,op))
                op_stack.append(s[i])
                i += 1
            # 不属于上述的情况，就字符会被压入
            else:
                i += 1
        # 最后把字符串s都遍历完了，最后还没有进行运算的，循环进行运算，最后结果放在数字栈内
        while op_stack:
            num1 = num_stack.pop()
            num2 = num_stack.pop()
            op = op_stack.pop()
            num_stack.append(apply_op(num2,num1,op))
        results = int(num_stack[0])
        return results
if __name__ == "__main__":
    s = str(input().strip().replace('"',''))
    print(Solution().solve(s))

python 的好处就体现出来了hh

class Solution:
    def solve(self , s: str) -> int:
        # write code here
        return eval(s)

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 返回表达式的值
# @param s string字符串 待计算的表达式
# @return int整型
#
#中缀表达式问题
class Solution:

    
    def solve(self , s: str) -> int:
        # 定义优先级
        level = {
            '*': 2,
            '-': 1,
            '+': 1,
            '(': 3,
            ')': -1
        }

        num = []
        signal = []

        # write code here
        signal.append('(')

        s = s + ')'

        l = len(s)
        i = 0
        while i < l:
            t = i
            while(s[t].isdigit()):
                t = t + 1
            
            
            if(t != i):
                num.append(int(s[i:t]))
                i = t
                continue
            
            if(signal[-1] == '(' and s[i] != ')'):
                signal.append(s[i])
                i = i + 1
            elif (level[s[i]] > level[signal[-1]]):
                signal.append(s[i])
                i = i + 1
            elif (level[s[i]] <= level[signal[-1]]):
                if (s[i] == ')' and signal[-1] == '('):
                    signal.pop()
                    i = i + 1
                else:
                    a = num.pop()
                    b = num.pop()
                    num.append(eval("{} {} {}".format(b, signal[-1], a)))
                    signal.pop()
        return num[-1]
                    
                    
                
        
        
        

A=input().replace('"','') print(eval(A))

class Solution:
    def solve(self , s ):
        # write code here
        self.op_priority = {'+': 0, '-': 0, '*': 1}
        suffix_expression = self.infix2suffix(s)
        return self.suffix2result(suffix_expression)
        
    def suffix2result(self, suffix_expression):
        stack = []
        for op in suffix_expression:
            if op not in ['+', '-', '*']:
                stack.append(int(op))
            else:
                num1 = stack.pop()
                num2 = stack.pop()
                if op == '+':
                    temp = num2 + num1
                elif op == '-':
                    temp = num2 - num1
                else:
                    temp = num2 * num1
                stack.append(temp)
        return stack.pop()
        
        
    def infix2suffix(self, s):
        sop, L, i = [], [], 0
        while i < len(s):
            if self.isNum(s[i]):
                num = ''
                while i < len(s) and self.isNum(s[i]):
                    num += s[i]
                    i += 1
                L.append(num)
            elif s[i] == '(':
                sop.append(s[i])
                i += 1
            elif s[i] == ')':
                while sop[-1] != '(':
                    L.append(sop.pop())
                sop.pop()
                i += 1
            else:
                while True:
                    if sop == []&nbs***bsp;sop[-1] == '('&nbs***bsp;(self.op_priority[s[i]] > self.op_priority[sop[-1]]):
                        sop.append(s[i])
                        break
                    else:
                        L.append(sop.pop())
                i += 1
        while sop:
            L.append(sop.pop())
        return L
    
    
    def isNum(self, ch):
        if ch in ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']:
            return True
        else:
            return False