feat: add solutions to lc problem: No.1006 (doocs#3069)

No.1006.Clumsy Factorial

Author: yanglbme

lcof2/剑指 Offer II 037. 小行星碰撞/README.md

@@ -227,7 +227,7 @@ impl Solution {
 class Solution {
     func asteroidCollision(_ asteroids: [Int]) -> [Int] {
         var stack = [Int]()
-        
+
         for asteroid in asteroids {
             if asteroid > 0 {
                 stack.append(asteroid)
@@ -242,7 +242,7 @@ class Solution {
                 }
             }
         }
-        
+
         return stack
     }
 }

lcof2/剑指 Offer II 038. 每日温度/README.md

@@ -188,15 +188,15 @@ class Solution {
         let n = temperatures.count
         var ans = [Int](repeating: 0, count: n)
         var stack = [Int]()
-        
+
         for i in 0..<n {
             while !stack.isEmpty && temperatures[stack.last!] < temperatures[i] {
                 let j = stack.removeLast()
                 ans[j] = i - j
             }
             stack.append(i)
         }
-        
+
         return ans
     }
 }

lcof2/剑指 Offer II 041. 滑动窗口的平均值/README.md

@@ -179,13 +179,13 @@ class MovingAverage {
     private var arr: [Int]
     private var s: Int
     private var cnt: Int
-    
+
     init(_ size: Int) {
         arr = [Int](repeating: 0, count: size)
         s = 0
         cnt = 0
     }
-    
+
     func next(_ val: Int) -> Double {
         let idx = cnt % arr.count
         s += val - arr[idx]

lcof2/剑指 Offer II 042. 最近请求次数/README.md

@@ -218,11 +218,11 @@ RecentCounter.prototype.ping = function (t) {
 ```swift
 class RecentCounter {
     private var q: [Int]
-    
+
     init() {
         q = []
     }
-    
+
     func ping(_ t: Int) -> Int {
         q.append(t)
         while q.first! < t - 3000 {

solution/1000-1099/1006.Clumsy Factorial/README.md

@@ -61,56 +61,148 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：栈 + 模拟
+
+笨阶乘的计算过程可以看作是一个栈的模拟过程。
+
+我们定义一个栈 `stk`，初始时我们将 $n$ 入栈，定义一个变量 $k$，表示当前的操作符，初始时 $k = 0$。
+
+然后我们从 $n-1$ 开始，枚举 $x$，根据当前的 $k$ 的值，决定如何处理 $x$：
+
+-   当 $k = 0$ 时，表示乘法操作，我们将栈顶元素出栈，与 $x$ 相乘后再入栈；
+-   当 $k = 1$ 时，表示除法操作，我们将栈顶元素出栈，与 $x$ 相除后取整数部分再入栈；
+-   当 $k = 2$ 时，表示加法操作，我们直接将 $x$ 入栈；
+-   当 $k = 3$ 时，表示减法操作，我们将 $-x$ 入栈。
+
+接着我们更新 $k = (k + 1) \mod 4$。
+
+最后，我们将栈中的元素累加即为答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为题目给定的整数 $N$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
 class Solution:
-    def clumsy(self, N: int) -> int:
-        op = 0
-        s = [N]
-        for i in range(N - 1, 0, -1):
-            if op == 0:
-                s.append(s.pop() * i)
-            elif op == 1:
-                s.append(int(s.pop() / i))
-            elif op == 2:
-                s.append(i)
+    def clumsy(self, n: int) -> int:
+        k = 0
+        stk = [n]
+        for x in range(n - 1, 0, -1):
+            if k == 0:
+                stk.append(stk.pop() * x)
+            elif k == 1:
+                stk.append(int(stk.pop() / x))
+            elif k == 2:
+                stk.append(x)
             else:
-                s.append(-i)
-            op = (op + 1) % 4
-        return sum(s)
+                stk.append(-x)
+            k = (k + 1) % 4
+        return sum(stk)
 ```
 
 #### Java
 
 ```java
 class Solution {
-    public int clumsy(int N) {
-        Deque<Integer> s = new ArrayDeque<>();
-        s.offerLast(N);
-        int op = 0;
-        for (int i = N - 1; i > 0; --i) {
-            if (op == 0) {
-                s.offerLast(s.pollLast() * i);
-            } else if (op == 1) {
-                s.offerLast(s.pollLast() / i);
-            } else if (op == 2) {
-                s.offerLast(i);
+    public int clumsy(int n) {
+        Deque<Integer> stk = new ArrayDeque<>();
+        stk.push(n);
+        int k = 0;
+        for (int x = n - 1; x > 0; --x) {
+            if (k == 0) {
+                stk.push(stk.pop() * x);
+            } else if (k == 1) {
+                stk.push(stk.pop() / x);
+            } else if (k == 2) {
+                stk.push(x);
             } else {
-                s.offerLast(-i);
+                stk.push(-x);
             }
-            op = (op + 1) % 4;
+            k = (k + 1) % 4;
         }
-        int res = 0;
-        while (!s.isEmpty()) {
-            res += s.pollLast();
+        return stk.stream().mapToInt(Integer::intValue).sum();
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int clumsy(int n) {
+        stack<int> stk;
+        stk.push(n);
+        int k = 0;
+        for (int x = n - 1; x; --x) {
+            if (k == 0) {
+                stk.top() *= x;
+            } else if (k == 1) {
+                stk.top() /= x;
+            } else if (k == 2) {
+                stk.push(x);
+            } else {
+                stk.push(-x);
+            }
+            k = (k + 1) % 4;
+        }
+        int ans = 0;
+        while (!stk.empty()) {
+            ans += stk.top();
+            stk.pop();
+        }
+        return ans;
+    }
+};
+```
+
+#### Go
+
+```go
+func clumsy(n int) (ans int) {
+	stk := []int{n}
+	k := 0
+	for x := n - 1; x > 0; x-- {
+		switch k {
+		case 0:
+			stk[len(stk)-1] *= x
+		case 1:
+			stk[len(stk)-1] /= x
+		case 2:
+			stk = append(stk, x)
+		case 3:
+			stk = append(stk, -x)
+		}
+		k = (k + 1) % 4
+	}
+	for _, x := range stk {
+		ans += x
+	}
+	return
+}
+```
+
+#### TypeScript
+
+```ts
+function clumsy(n: number): number {
+    const stk: number[] = [n];
+    let k = 0;
+    for (let x = n - 1; x; --x) {
+        if (k === 0) {
+            stk.push(stk.pop()! * x);
+        } else if (k === 1) {
+            stk.push((stk.pop()! / x) | 0);
+        } else if (k === 2) {
+            stk.push(x);
+        } else {
+            stk.push(-x);
         }
-        return res;
+        k = (k + 1) % 4;
     }
+    return stk.reduce((acc, cur) => acc + cur, 0);
 }
 ```