Add python solutions to all array problems

Author: enginebai

leetcode/238.product-of-array-except-self.md

@@ -1,22 +1,37 @@
 ## [238. Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self)
 
-The product except self comes from the prefix and suffix of `i`. And we can calculate the prefix / suffix from the first and last index:
+For the index `i`, we can calculate the product of all elements before `i` and all elements after `i`. That is the prefix and suffix product. So we can iterate to calculate the product of all elements to the left of each element and all elements to the right of each element.
 
 ```js
-|Prefix| X |Suffix|
+|Prefix| i |Suffix|
 ```
 
 * `prefix[i] = prefix[i - 1] * nums[i - 1]`
 * `suffix[i] = suffix[i + 1] * nums[i + 1]`
 
 ```js
-           2, 3, 5
+input     [2, 3, 5]
 prefix[i]  1  2  6   
 suefix[i] 15  5  1
 ```
 
 Then we multiple the prefix and suffix together.
 
+```python
+def productExceptSelf(self, nums: List[int]) -> List[int]:
+    n = len(nums)
+    prefix_prod = [1] * n
+    suffix_prod = [1] * n
+    for i in range(1, n):
+        prefix_prod[i] = prefix_prod[i - 1] * nums[i - 1]
+    for i in range(n - 2, -1, -1):
+        suffix_prod[i] = suffix_prod[i + 1] * nums[i + 1]
+
+    answer = [1] * n
+    for i in range(0, n):
+        answer[i] = prefix_prod[i] * suffix_prod[i]
+    return answer
+```
 
 ```kotlin
 fun productExceptSelf(nums: IntArray): IntArray {
@@ -39,8 +54,24 @@ fun productExceptSelf(nums: IntArray): IntArray {
 }
 ```
 
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.
+
 ### Space Optimization
-We can use `prefixProducts` as answer array (the answer array does not count as extra space), and keep track the suffix to get the answer.
+We can use answer array as prefix product (the answer array does not count as extra space), and keep track the suffix to get the answer.
+
+```python
+def productExceptSelf(self, nums: List[int]) -> List[int]:
+    n = len(nums)
+    answers = [1] * n
+    for i in range(1, n):
+        answers[i] = answers[i - 1] * nums[i - 1]
+    suffix = nums[n - 1]
+    for i in range(n - 2, -1, -1):
+        answers[i] *= suffix
+        suffix *= nums[i]
+    return answers
+```
 
 ```kotlin
 fun productExceptSelf(nums: IntArray): IntArray {
@@ -51,10 +82,12 @@ fun productExceptSelf(nums: IntArray): IntArray {
     }
     var suffix = nums[nums.size - 1]
     for (i in nums.size - 2 downTo 0) {
-        answers[i] = answers[i] * suffix
+        answers[i] *= suffix
         suffix *= nums[i]
     }
-
     return answers
 }
-```
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(1)`.

leetcode/2874.maximum-value-of-an-ordered-triplet-ii.md

@@ -1,29 +1,49 @@
 ## [2874. Maximum Value of an Ordered Triplet II](https://leetcode.com/problems/maximum-value-of-an-ordered-triplet-ii/description/)
 
-To find the maximum value of `(nums[i] - nums[j]) * nums[k]` where `i < j < k`, we try to find the maximum of `nums[i]` from left and `nums[k]` from right. Then we iterate `nums[j]` from left to right to find the maximum value.
+To find the maximum value of `(nums[i] - nums[j]) * nums[k]` where `i < j < k`, we try to find the maximum of `nums[i]` from left and `nums[k]` from right. Then we iterate `nums[j]` as minimum to find the global maximum value.
+
+> TODO: There is a better solution with O(1) space complexity.
+
+```python
+def maximumTripletValue(self, nums: List[int]) -> int:
+    # (A[i] - A[j]) * A[k]
+    #  max    min     max
+    # (    max    ) * max
+    n = len(nums)
+    left_max = [0] * n
+    right_max = [0] * n
+    left_max[0] = nums[0]
+    for i in range(1, n):
+        left_max[i] = max(left_max[i - 1], nums[i])
+    right_max[-1] = nums[-1]
+    for i in range(n - 2, -1, -1):
+        right_max[i] = max(right_max[i + 1], nums[i])
+    
+    answer = -inf
+    for i in range(1, n - 1):
+        answer = max(answer, (left_max[i - 1] - nums[i]) * right_max[i + 1])
+    return answer if answer > 0 else 0
+```
 
 ```kotlin
 fun maximumTripletValue(nums: IntArray): Long {
     val n = nums.size
-    // The max from left to right
-    val maxLeft = IntArray(n)
-    // The max from right to left
-    val maxRight = IntArray(n)
-    
-    maxLeft[0] = nums[0]
-    maxRight[n - 1] = nums[n - 1]
-    
+    val leftMax = IntArray(n) { Int.MIN_VALUE }
+    val rightMax = IntArray(n) { Int.MIN_VALUE }
+    leftMax[0] = nums[0]
     for (i in 1 until n) {
-        maxLeft[i] = maxOf(maxLeft[i - 1], nums[i])
+        leftMax[i] = maxOf(leftMax[i - 1], nums[i])
     }
+    rightMax[n - 1] = nums[n - 1]
     for (i in n - 2 downTo 0) {
-        maxRight[i] = maxOf(maxRight[i + 1], nums[i])
+        rightMax[i] = maxOf(rightMax[i + 1], nums[i])
     }
-    
     var result = Long.MIN_VALUE
     for (i in 1 until n - 1) {
-        result = maxOf(result, (maxLeft[i - 1] - nums[i]) * maxRight[i + 1].toLong())
+        result = maxOf(result, (leftMax[i - 1] - nums[i]).toLong() * rightMax[i + 1])
     }
     return if (result < 0) 0 else result
 }
-```
+```
+* **Time Complexity**: O(n).
+* **Space Complexity**: O(n).

leetcode/2909.minimum-sum-of-mountain-triplets-ii.md

@@ -0,0 +1,51 @@
+## [2909. Minimum Sum of Mountain Triplets II](https://leetcode.com/problems/minimum-sum-of-mountain-triplets-ii/description/)
+
+### Prefix && Surfix
+We're going to find the minimum sum of mountain triplets. To minimize the sum, we can find the minimum of the first and the third number, then iterate the second number as peak to find the global minimum sum.
+
+```python
+def minimumSum(self, nums: List[int]) -> int:
+    n = len(nums)
+    left_min = [0] * n
+    right_min = [0] * n
+    left_min[0] = nums[0]
+    for i in range(1, n):
+        left_min[i] = min(left_min[i - 1], nums[i])
+    
+    right_min[-1] = nums[-1]
+    for i in range(n - 2, -1, -1):
+        right_min[i] = min(right_min[i + 1], nums[i])
+
+    answer = inf
+    for i in range(1, n - 1):
+        if left_min[i - 1] < nums[i] and right_min[i + 1] < nums[i]:
+            answer = min(answer, left_min[i - 1] + nums[i] + right_min[i + 1])
+    return answer if answer != inf else -1
+```
+
+```kotlin
+fun minimumSum(nums: IntArray): Int {
+    val n = nums.size
+    // The min value when consider current value and left part
+    val leftMin = IntArray(n) { Int.MAX_VALUE }
+    val rightMin = IntArray(n)
+
+    for (i in 1 until n) {
+        leftMin[i] = minOf(nums[i], leftMin[i - 1])
+    }
+    rightMin[n - 1] = nums[n - 1]
+    for (i in n - 2 downTo 0) {
+        rightMin[i] = minOf(nums[i], rightMin[i + 1])
+    }
+    var minSum = Int.MAX_VALUE
+    for (i in 1 until n - 1) {
+        // Remember this check if the triplets are valid mountain
+        if (leftMin[i - 1] < nums[i] && rightMin[i + 1] < nums[i]) {
+            minSum = minOf(minSum, leftMin[i - 1] + nums[i] + rightMin[i + 1])
+        }
+    }
+    return if (minSum == Int.MAX_VALUE) -1 else minSum
+}
+```
+* **Time Complexity**: O(n).
+* **Space Complexity**: O(n).

leetcode/621.task-scheduler.md

@@ -46,7 +46,7 @@ fun leastInterval(tasks: CharArray, n: Int): Int {
         counts[task - 'A']++
         val count = counts[task - 'A']
         if (max < count) {
-            max = count
+            max = count`
             maxCount = 1
         } else if (max == count) {
             maxCount++

leetcode/845.longest-mountain-in-array.md

@@ -1,24 +1,45 @@
 ## [845. Longest Mountain in Array](https://leetcode.com/problems/longest-mountain-in-array)
 
 ### Two Pointers
-We locale the starting index of mountain, if found then start to climb the mountain. (mind the case it only goes up no down).
+We iterate the starting point to climb, then try to finish the mountain. If we can find the peak and the down side, then we can calculate the length of the mountain.
+
+```python
+def longestMountain(self, arr: List[int]) -> int:
+    n = len(arr)
+    start = 0
+    end = 0
+    max_length = 0
+    while start < n:
+        if start + 1 < n and arr[start] < arr[start + 1]:
+            end = start
+            while end + 1 < n and arr[end] < arr[end + 1]:
+                end += 1
+            if end + 1 < n and arr[end] > arr[end + 1]:
+                while end + 1 < n and arr[end] > arr[end + 1]:
+                    end += 1
+                max_length = max(max_length, end - start + 1)
+            start = end
+        else:
+            start += 1
+    return max_length
+```
 
 ```kotlin
 fun longestMountain(arr: IntArray): Int {
     var start = 0
     var end = 0
     var maxLength = 0
     while (start < arr.size) {
-        // If we can start to climb
+        // We find the starting point to climb
         if (start + 1 < arr.size && arr[start] < arr[start + 1]) {
             end = start
-            // Go up to find the peak
+            // Keep going up to find the peak
             while (end + 1 < arr.size && arr[end] < arr[end + 1]) {
                 end++
             }
-            // We have make sure there is down side.
+            // Then start to go down
             if (end + 1 < arr.size && arr[end] > arr[end + 1]) {
-                // Go down
+                // Keep going down
                 while (end + 1 < arr.size && arr[end] > arr[end + 1]) {
                     end++
                 }
@@ -32,12 +53,51 @@ fun longestMountain(arr: IntArray): Int {
     }
     return maxLength
 }
+
+// Or same idea with the same implementation of [941. Valid Mountain Array](941.valid-mountain-array.md)
+fun longestMountain(arr: IntArray): Int {
+    var longest = 0
+    if (arr.size < 3) return 0
+    var start = 0
+    var end = 0
+    while (start + 1 < arr.size) {
+        // Find the starting point to climb
+        if (arr[start] < arr[start + 1]) {
+            end = start + 1
+            var goUp = false
+            var goDown = false
+            // Try to finish the mountain
+            while (end < arr.size) {
+                if (arr[end - 1] < arr[end]) {
+                    if (goDown) break
+                    goUp = true
+                } else if (arr[end - 1] > arr[end]) {
+                    if (!goUp) break
+                    goDown = true
+                } else {
+                    break
+                }
+                end++
+            }
+            // If we find the valid mountain
+            if (goUp && goDown) {
+                longest = maxOf(longest, end - start)
+            }
+            // End - 1 because `end` is the first element that breaks the mountain, so we need to go back one step.
+            start = end - 1
+        } else {
+            start++
+        }
+    }
+    return longest
+}
 ```
 * **Time Complexity**: `O(n)`.
 * **Space Complexity**: `O(1)`.
 
 
 ### Simulation (AC)
+> Feel free to skip the following solution since it's more complex than the above one.
 ```kotlin
 // 
 // up, up: skip