基本计算器1、2、3、4 / 679. 24 点游戏（H）/ 150. 逆波兰表达式求值（M）

227. 加减乘除

• 题解

import collections
class Solution:
    def calculate(self, s: str) -> int:
        n = len(s)
        s = collections.deque(s)
        num = 0
        sign = "+"
        # 栈用于存储数字及其附带的正负号
        # 最后用于把所有数字加起来
        res = []
        
        for i in range(n):
        	# 这里已经弹出s前面的字符
            char = s.popleft()
            
            # 若是数字则计算数字，考虑是否为多位数
            if char.isdigit():
                num = num * 10 + int(char)
                
            # 若字符非空且不为数字 或 s为空时处理最后一个num和sign
            if (not char.isdigit() and char != " ") or not s:
                if sign == "+":
                    res.append(num)
                if sign == "-":
                    res.append(-num)
                # 乘法需要弹出栈顶的（最近的）数字，计算完后再把计算结果加入栈中
                if sign == "*":
                    res.append(res.pop() * num)
                # 除法同上
                if sign == "/":
                    res.append(int(res.pop() / num))
                num = 0
                sign = char # 保存当前的计算符号，用于后面的计算
                
        return sum(res)

224. 加减+括号

• 题解

class Solution:
    def calculate(self, s: str) -> int:
    	# 栈来存储符号，
    	# 栈顶元素表示当前位置的括号由前面所有符号共同决定的符号
        ops = [1]
        sign = 1

        res = 0
        n = len(s)
        i = 0
        while i < n:
        	# 跳过空格
            if s[i] == ' ':
                i += 1
            # 遇到+，则符号位为栈顶元素
            elif s[i] == '+':
                sign = ops[-1]
                i += 1
            # 遇到-，则符号位为栈顶元素取反
            elif s[i] == '-':
                sign = -ops[-1]
                i += 1
            # 遇到左括号，则加入当前括号前面的符号位
            elif s[i] == '(':
                ops.append(sign)
                i += 1
            # 遇到右括号，则弹出栈顶的符号位
            elif s[i] == ')':
                ops.pop()
                i += 1
            # 若是数字，则进行计算
            else:
                num = 0
                # 若是多位数，则先计算出此多位数
                while i < n and s[i].isdigit():
                    num = num * 10 + ord(s[i]) - ord('0')
                    i += 1
                # 对值进行累加，考虑最近的符号位
                res += num * sign
                
        return res

772. 加减乘除+括号

• 题解

class Solution:
    def calculate(self, s):
        from collections import deque
        # 递归计算每个括号内表达式的计算结果
        def recur(s):
            # 栈用来存储每部分数字及其附带的正负号，最后用于把栈中所有数字加起来得到当前部分的结果
            stack = []
            sign = '+'
            num = 0

            while len(s) > 0:
                # 在这里已经把s前面的字符弹出
                c = s.popleft()
                
                # 若是数字则计算数字，考虑是否为多位数
                if c.isdigit():
                    num = 10 * num + int(c)

                # 遇到左括号，则进行递归计算括号内的表达式
                if c == '(':
                    num = recur(s)
                
                # 若字符非空且不为数字 或 s为空时处理最后一个num和sign
                if c in '+-*/()' or not s:
                    if sign == '+':
                        stack.append(num)
                    elif sign == '-':
                        stack.append(-num)
                    # 乘法需要弹出栈顶的（最近的）数字，计算完后再把计算结果加入栈中
                    elif sign == '*':
                        stack.append(stack.pop() * num)
                    # 除法同上
                    elif sign == '/':
                        # 向0取整
                        stack.append(int(stack.pop() / num))
                    num = 0
                    sign = c

                # 遇到右括号，则停止
                if c == ')':
                    break

            return sum(stack) # 把栈中所有数字加起来得到当前部分的结果
            
        return recur(deque(s))

加减乘+括号

# @param s string字符串 待计算的表达式
# @return int整型
#
class Solution:
    def solve(self , s ):
        # write code here
        stack = []
        sign = '+'
        num = 0
        i = 0
        while i < len(s): # 是否小于当前子串s的长度
            c = s[i]
            if c == '(':
                j = i + 1 # 从数字开始
                count = 1 # count为正表示括号还未结束
                while count > 0:
                    if s[j] == '(':
                        count += 1
                    elif s[j] == ')':
                        count -= 1
                    j += 1
                    
                num = self.solve(s[i+1:j-1]) # 递归
                i = j - 1 # i从当前括号的后面开始计算剩余的式子
                
            if c.isdigit(): # 是数字？
                num = num * 10 + (ord(c) - ord('0'))
                
            # 不是数字 or 已经到达最后一个字符
            if not c.isdigit() or i == len(s) - 1:
                if sign == '+':
                    stack.append(num)
                elif sign == '-':
                    stack.append(-num)
                elif sign == '*':
                    stack[-1] = stack[-1] * num
                sign = c
                num = 0
            i += 1
            
        return sum(stack)

计算器4

题目链接

679. 24 点游戏

• 官方题解

• 解法2（推荐）

class Solution:
	# 使用栈、队列来模拟
    def judgePoint24(self, cards: List[int]) -> bool:
        if len(cards) == 1:
            return math.isclose(cards[0], 24)
        
        for _ in range(len(cards)):
            a = cards.pop(0) # 摸一张 (queue 操作)

            for _ in range(len(cards)):
                b = cards.pop(0) # 再摸一张 (queue 操作)

                for value in [a + b, a - b, a * b, b and a / b]: # 算一下
                    cards.append(value) # 记下来 (stack 操作)
                    if self.judgePoint24(cards):
                        return True
                    cards.pop() # (stack 操作)

                cards.append(b) # (queue 操作)

            cards.append(a) # (queue 操作)

        return False

150. 逆波兰表达式求值

• python题解
  
  
  

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        def compute(num1, num2, op):
            if op == "+":
                return num1 + num2
            elif op == "-":
                return num1 - num2
            elif op == "*":
                return num1 * num2
            elif op == "/":
                return int(num1 / float(num2)) # 整数除法
            
        stack = []
        for token in tokens:
            # 注意：在python中，只能通过异常语句来判断一个字符串是否为合理的整数（包括正、负数）
            try:
                stack.append(int(token))
            except:
                num2 = stack.pop()
                num1 = stack.pop()
                stack.append(compute(num1, num2, token))

        return stack[0]