1006. 笨阶乘

概述

展开为算术表达式，不带括号，然后向下取整
那这道题就是计算表达式就行了，计算表达式在之前的博文里面有介绍，这里再复习一下

题解

暴力 表达式求值

按照题意我们需要生成算术表达式

        s = [] 
        op = ['*','/','+','-']
        ind = 0
        for i in range(N,0,-1):
            s.append(i)
            if i != 1:
                s.append(op[ind])
                ind = (ind+1) % len(op)
        
        s.append('+')

用s来存储，最后append+是为了后续计算方便

然后我们用同样的思路来处理这个不带括号的表达式

        stack = []
        sign = '+'
        num = 0
        for i in s:
            if type(i) == int:
                num = i  
            else:
                if sign == '*':
                    stack[-1] *= num
                elif sign == '/':
                    stack[-1] = int(stack[-1]/num)
                elif sign == '+':
                    stack.append(num)
                elif sign == '-':
                    stack.append(-num)
                sign = i
                num = 0

sign是前一个符号，num也是前一个数字，每当我们遇到一个新的符号的时候，就按照sign的对应符号进行操作
之所以前面要append +，是因为我们要对最后一个数字进行处理

整合一下就能写出完整代码了：

    def clumsy(self, N: int) -> int:
        s = [] 
        op = ['*','/','+','-']
        ind = 0
        for i in range(N,0,-1):
            s.append(i)
            if i != 1:
                s.append(op[ind])
                ind = (ind+1) % len(op)
        
        s.append('+')

        stack = []
        sign = '+'
        num = 0
        for i in s:
            if type(i) == int:
                num = i  
            else:
                if sign == '*':
                    stack[-1] *= num
                elif sign == '/':
                    stack[-1] = int(stack[-1]/num)
                elif sign == '+':
                    stack.append(num)
                elif sign == '-':
                    stack.append(-num)
                sign = i
                num = 0
        
        return sum(stack)

优化暴力

实际上我们可以一边生成表达式一边算

class Solution:
    def clumsy(self, N: int) -> int:
        stack = []
        sign = '+'

        ind = 0 
        op = ['*','/','+','-']

        while N:
            if sign == '*':
                stack[-1] *= N
            elif sign == '/':
                stack[-1] = int(stack[-1]/N)
            elif sign == '+':
                stack.append(N)
            elif sign == '-':
                stack.append(-N)
            N -= 1
            sign = op[ind]
            ind = (ind+1)%4
        
        return sum(stack)

看起来简洁了一些

循环计算

class Solution:
    def clumsy(self, N: int) -> int:
        if N <= 2:
            return N 
        if N == 3:
            return 6

        ans = int(N*(N-1)/(N-2))+N-3
        N -= 4
        while N >= 4:
            # 一组符号
            ans += -1*int(N*(N-1)/(N-2))+N-3
            N -= 4

        return ans - self.clumsy(N)

我们用三个一组的形式来记录，然后找出规律，如果N<=3我们直接返回相应的结果，如果N大于等于4，那么我们先累加一组，然后不断计算循环体内的表达式，最终返回剩下的结果即可

比上面的栈要快很多

数学

通过暴力打表找出规律，n~n+4的答案相差为[1,2,2,-1]，那么可以直接用规律得出

class Solution:
    def clumsy(self, N: int) -> int:
        if N<=4:
            return [1,2,6,7][N-1]
        return N + [1,2,2,-1][N%4]

打表找规律的基础是你先要有一个正确的解法然后再拿它去打表，这才能找到正确的规律，所以暴力法其实很重要