[Swift]LeetCode1006. 笨階乘 | Clumsy Factorial

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公衆號：山青詠芝（shanqingyongzhi）
➤博客園地址：山青詠芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： http://www.javashuo.com/article/p-vxojesfl-md.html 
➤若是連接不是山青詠芝的博客園地址，則多是爬取做者的文章。
➤原文已修改更新！強烈建議點擊原文地址閱讀！支持做者！支持原創！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

Normally, the factorial of a positive integer n is the product of all positive integers less than or equal to n.  For example, factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1.

We instead make a clumsy factorial: using the integers in decreasing order, we swap out the multiply operations for a fixed rotation of operations: multiply (*), divide (/), add (+) and subtract (-) in this order.

For example, clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1.  However, these operations are still applied using the usual order of operations of arithmetic: we do all multiplication and division steps before any addition or subtraction steps, and multiplication and division steps are processed left to right.

Additionally, the division that we use is floor division such that 10 * 9 / 8 equals 11.  This guarantees the result is an integer.

Implement the clumsy function as defined above: given an integer N, it returns the clumsy factorial of N. 

Example 1:

Input: 4
Output: 7
Explanation: 7 = 4 * 3 / 2 + 1

Example 2:

Input: 10
Output: 12 Explanation: 12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1 

Note:

1. 1 <= N <= 10000
2. -2^31 <= answer <= 2^31 - 1  (The answer is guaranteed to fit within a 32-bit integer.)

---

一般，正整數 n 的階乘是全部小於或等於 n 的正整數的乘積。例如，factorial(10) = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1。

相反，咱們設計了一個笨階乘 clumsy：在整數的遞減序列中，咱們以一個固定順序的操做符序列來依次替換原有的乘法操做符：乘法(*)，除法(/)，加法(+)和減法(-)。

例如，clumsy(10) = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1。然而，這些運算仍然使用一般的算術運算順序：咱們在任何加、減步驟以前執行全部的乘法和除法步驟，而且按從左到右處理乘法和除法步驟。

另外，咱們使用的除法是地板除法（floor division），因此 10 * 9 / 8 等於 11。這保證結果是一個整數。

實現上面定義的笨函數：給定一個整數 N，它返回 N 的笨階乘。 

示例 1：

輸入：4
輸出：7
解釋：7 = 4 * 3 / 2 + 1

示例 2：

輸入：10
輸出：12
解釋：12 = 10 * 9 / 8 + 7 - 6 * 5 / 4 + 3 - 2 * 1 

提示：

1. 1 <= N <= 10000
2. -2^31 <= answer <= 2^31 - 1  （答案保證符合 32 位整數。）

---

Runtime: 4 ms

Memory Usage: 18.9 MB

 1 class Solution {    
 2     func clumsy(_ N: Int) -> Int
 3     {
 4         if N == 1 {return 1}
 5         if N == 2 {return 2}
 6         if N == 3 {return 3 * 2 / 1}
 7         return N * (N - 1) / (N - 2) + clumsyInternal(N - 3)      
 8     }
 9     
10     func clumsyInternal(_ N: Int) -> Int {
11         if N == 0 {return 0}
12         if N == 1 {return 1}
13         if N == 2 {return 1}
14         if N == 3 {return 3 - 2 * 1}
15         var ans:Int = N - (N - 1) * (N - 2) / (N - 3)
16         return ans + clumsyInternal(N - 4)
17     }
18 }

---

 

4ms

 1 class Solution {
 2     func clumsy(_ n: Int) -> Int {
 3         if n == 1 {
 4             return 1
 5         } else if n == 2 {
 6             return 2
 7         } else if n == 3 {
 8             return 6
 9         }
10         var result = n*(n-1)/(n-2)
11         var n = n-3
12         while n >= 4 {
13             result += n - (n-1)*(n-2)/(n-3)
14             n -= 4
15         }
16         if n > 0 {
17             result += 1
18         }
19         return result
20     }
21 }

---

4ms

 1 class Solution {    
 2     func clumsy(_ n: Int) -> Int {
 3         switch n {
 4             case 1:
 5                 return 1
 6             case 2:
 7                 return 2
 8             case 3: 
 9                 return 6
10             default:
11                 return n*(n-1)/(n-2) + clumsyInternal(n-3)
12         }
13     }
14     
15     func clumsyInternal(_ n : Int ) -> Int {
16         if n >= 4 {
17             return n - (n-1)*(n-2)/(n-3) + clumsyInternal(n-4)
18         }
19         if n == 0 {
20             return 0
21         }
22         return 1
23     }
24 }

---

112ms

  1 class Solution {
  2     enum Operation: Int {
  3         case mul
  4         case div
  5         case add
  6         case sub
  7 
  8         func next() -> Operation {
  9             return Operation(rawValue: (self.rawValue + 1) % 4 )!
 10         }
 11     }
 12 
 13     struct OperationCluster {
 14         var current: Operation {
 15             return operations[currentIndex]
 16         }
 17 
 18         var currentIndex: Int
 19 
 20         let operations: [Operation]
 21         init(operations: [Operation]) {
 22             self.operations = operations
 23             self.currentIndex = 0
 24         }
 25 
 26         mutating func next() {
 27             currentIndex = (currentIndex + 1) % operations.count
 28         }
 29     }
 30 
 31     func clumsy(_ N: Int) -> Int {
 32         var a = [Int]()
 33 
 34         for i in 0..<N {
 35             a.append(N-i)
 36         }
 37 
 38         var multiplied = [Int]()
 39 
 40         var operationCluster = OperationCluster(operations: [.mul, .div, .add, .sub])
 41         var ignoreNextOperand = false
 42 
 43         for (index, number) in a.enumerated() {
 44             defer {
 45                 operationCluster.next()
 46             }
 47 
 48             guard ignoreNextOperand == false else {
 49                 ignoreNextOperand = false
 50                 continue
 51             }
 52 
 53             switch operationCluster.current {
 54             case .mul:
 55                 let result = number * (next(in: a, after: index) ?? 1)
 56                 multiplied.append(result)
 57                 ignoreNextOperand = true
 58             case .div:
 59                 multiplied.append(number)
 60             case .add:
 61                 multiplied.append(number)
 62             case .sub:
 63                 multiplied.append(number)
 64             }
 65         }
 66 
 67         operationCluster = OperationCluster(operations: [.div, .add, .sub])
 68         ignoreNextOperand = false
 69 
 70         var divided = [Int]()
 71 
 72         for (index, number) in multiplied.enumerated() {
 73             defer {
 74                 operationCluster.next()
 75             }
 76 
 77             guard ignoreNextOperand == false else {
 78                 ignoreNextOperand = false
 79                 continue
 80             }
 81 
 82             switch operationCluster.current {
 83             case .mul:
 84                 assertionFailure()
 85                 break
 86             case .div:
 87                 let result = number / (next(in: multiplied, after: index) ?? 1)
 88                 divided.append(result)
 89                 ignoreNextOperand = true
 90             case .add:
 91                 divided.append(number)
 92             case .sub:
 93                 divided.append(number)
 94             }
 95         }
 96 
 97         operationCluster = OperationCluster(operations: [.add, .sub])
 98         ignoreNextOperand = false
 99 
100         var signApplied = [Int]()
101 
102         signApplied.append(divided.first ?? 0)
103 
104         for (index, number) in divided.enumerated() {
105             defer {
106                 operationCluster.next()
107             }
108 
109             guard ignoreNextOperand == false else {
110                 ignoreNextOperand = false
111                 continue
112             }
113 
114             switch operationCluster.current {
115             case .mul:
116                 assertionFailure()
117                 break
118             case .div:
119                 assertionFailure()
120                 break
121             case .add:
122                 signApplied.append(next(in: divided, after: index) ?? 0)
123             case .sub:
124                 signApplied.append(-(next(in: divided, after: index) ?? 0))
125             }
126         }
127 
128         return signApplied.reduce(0, +)
129     }
130 
131     func next(in array: [Int], after index: Int) -> Int? {
132         let maxIndex = array.count - 1
133         if maxIndex <= index {
134             return nil
135         }
136         return array[index + 1]
137     }
138 }