feat(python): solutions

Author: hongbo-miao

JavaScript/0062. Unique Paths.js

@@ -29,26 +29,13 @@
 
 // 1) Dynamic programming
 // Time O(mn)
-// Space O(n)
+// Space O(mn)
 //
 // Example
-// 1   1  (1)  1  1  1  (init current row to 1)
+// 1   1  (1)  1  1  1
 // 1  (2) (3)  4  5  6  (e.g. 3 = 1 + 2)
-// 1   3   6  10 15 21  (return the last number in the last row which is 21)
+// 1   3   6  10 15 21
 const uniquePaths1 = (m, n) => {
-  const row = Array(n).fill(1);
-  for (let i = 1; i < m; i++) {
-    for (let j = 1; j < n; j++) {
-      row[j] += row[j - 1];
-    }
-  }
-  return row[n - 1];
-};
-
-// 2)
-// Time O(mn)
-// Space O(mn)
-const uniquePaths = (m, n) => {
   // init first row and col to 1, and the rest to 0
   const matrix = [];
   for (let i = 0; i < m; i++) {
@@ -67,3 +54,28 @@ const uniquePaths = (m, n) => {
   }
   return matrix[m - 1][n - 1];
 };
+
+// 2) Dynamic programming (optimization)
+// Time O(mn)
+// Space O(n)
+//
+// i j dp
+// 1 1 [1, 2, 1, 1, 1, 1]
+// 1 2 [1, 2, 3, 1, 1, 1]
+// 1 3 [1, 2, 3, 4, 1, 1]
+// 1 4 [1, 2, 3, 4, 5, 1]
+// 1 5 [1, 2, 3, 4, 5, 6]
+// 2 1 [1, 3, 3, 4, 5, 6]
+// 2 2 [1, 3, 6, 4, 5, 6]
+// 2 3 [1, 3, 6, 10, 5, 6]
+// 2 4 [1, 3, 6, 10, 15, 6]
+// 2 5 [1, 3, 6, 10, 15, 21]
+const uniquePaths = (m, n) => {
+  const row = Array(n).fill(1);
+  for (let i = 1; i < m; i++) {
+    for (let j = 1; j < n; j++) {
+      row[j] += row[j - 1];
+    }
+  }
+  return row[n - 1];
+};

JavaScript/0066. Plus One.js

@@ -24,8 +24,10 @@ const plusOne = (digits) => {
   let i = digits.length;
 
   while (i--) {
-    digits[i] += 1;
-    if (digits[i] < 10) return digits;
+    if (digits[i] < 9) {
+      digits[i] += 1;
+      return digits;
+    }
     digits[i] = 0;
   }
 

JavaScript/0070. Climbing Stairs.js

@@ -39,11 +39,11 @@ const climbStairs1 = (n) => {
 // Space O(n)
 const climbStairs2 = (n) => {
   const map = {};
-  const go = (n) => {
-    if (n < 2) return 1;
-    if (map[n] != null) return map[n];
-    map[n] = go(n - 2) + go(n - 1);
-    return map[n];
+  const go = (i) => {
+    if (i < 2) return 1;
+    if (map[i] != null) return map[i];
+    map[i] = go(i - 2) + go(i - 1);
+    return map[i];
   };
   return go(n);
 };

Python/0062. Unique Paths.py

@@ -0,0 +1,66 @@
+# There is a robot on an m x n grid. The robot is initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m - 1][n - 1]). The robot can only move either down or right at any point in time.
+# Given the two integers m and n, return the number of possible unique paths that the robot can take to reach the bottom-right corner.
+# The test cases are generated so that the answer will be less than or equal to 2 * 10^9.
+#
+# Example 1:
+#
+# Input: m = 3, n = 7
+# Output: 28
+#
+# Example 2:
+#
+# Input: m = 3, n = 2
+# Output: 3
+# Explanation: From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+# 1. Right -> Down -> Down
+# 2. Down -> Down -> Right
+# 3. Down -> Right -> Down
+#
+# Constraints:
+#
+# 1 <= m, n <= 100
+
+
+# 1) Dynamic programming
+# Time O(mn)
+# Space O(mn)
+#
+# Example
+# 1   1  (1)  1  1  1
+# 1  (2) (3)  4  5  6  (e.g. 3 = 1 + 2)
+# 1   3   6  10 15 21
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = [[0] * n for _ in range(m)]
+        for i in range(m):
+            for j in range(n):
+                if i == 0 or j == 0:
+                    dp[i][j] = 1
+                else:
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[-1][-1]
+
+
+# 2) Dynamic programming (optimization)
+# Time O(mn)
+# Space O(n)
+#
+# Example
+# i j dp
+# 1 1 [1, 2, 1, 1, 1, 1]
+# 1 2 [1, 2, 3, 1, 1, 1]
+# 1 3 [1, 2, 3, 4, 1, 1]
+# 1 4 [1, 2, 3, 4, 5, 1]
+# 1 5 [1, 2, 3, 4, 5, 6]
+# 2 1 [1, 3, 3, 4, 5, 6]
+# 2 2 [1, 3, 6, 4, 5, 6]
+# 2 3 [1, 3, 6, 10, 5, 6]
+# 2 4 [1, 3, 6, 10, 15, 6]
+# 2 5 [1, 3, 6, 10, 15, 21]
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = [1] * n
+        for _ in range(1, m):
+            for j in range(1, n):
+                dp[j] += dp[j - 1]
+        return dp[-1]

Python/0066. Plus One.py

@@ -1,34 +1,43 @@
-# Given a non-empty array of digits representing a non-negative integer, plus one to the integer.
-#
-# The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.
-#
-# You may assume the integer does not contain any leading zero, except the number 0 itself.
+# You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading 0's.
+# Increment the large integer by one and return the resulting array of digits.
 #
 # Example 1:
 #
-# Input: [1,2,3]
+# Input: digits = [1,2,3]
 # Output: [1,2,4]
 # Explanation: The array represents the integer 123.
+# Incrementing by one gives 123 + 1 = 124.
+# Thus, the result should be [1,2,4].
 #
 # Example 2:
 #
-# Input: [4,3,2,1]
+# Input: digits = [4,3,2,1]
 # Output: [4,3,2,2]
 # Explanation: The array represents the integer 4321.
+# Incrementing by one gives 4321 + 1 = 4322.
+# Thus, the result should be [4,3,2,2].
+#
+# Example 3:
+#
+# Input: digits = [9]
+# Output: [1,0]
+# Explanation: The array represents the integer 9.
+# Incrementing by one gives 9 + 1 = 10.
+# Thus, the result should be [1,0].
+#
+# Constraints:
+#
+# 1 <= digits.length <= 100
+# 0 <= digits[i] <= 9
+# digits does not contain any leading 0's.
 
 
 class Solution:
     def plusOne(self, digits: List[int]) -> List[int]:
-        i = len(digits) - 1
-
-        while i >= 0:
-            digits[i] += 1
-
-            if digits[i] < 10:
+        for i in range(len(digits) - 1, -1, -1):
+            if digits[i] < 9:
+                digits[i] += 1
                 return digits
-
             digits[i] = 0
-            i -= 1
-
         digits.insert(0, 1)
         return digits

Python/0070. Climbing Stairs.py

@@ -0,0 +1,94 @@
+# You are climbing a staircase. It takes n steps to reach the top.
+# Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+#
+# Example 1:
+#
+# Input: n = 2
+# Output: 2
+# Explanation: There are two ways to climb to the top.
+# 1. 1 step + 1 step
+# 2. 2 steps
+#
+# Example 2:
+#
+# Input: n = 3
+# Output: 3
+# Explanation: There are three ways to climb to the top.
+# 1. 1 step + 1 step + 1 step
+# 2. 1 step + 2 steps
+# 3. 2 steps + 1 step
+#
+# Constraints:
+#
+# 1 <= n <= 45
+
+
+# 1) Recursion (time limit exceeded)
+# Time O(2^n) - O(branch ^ recursion depth)
+# Space O(n) - O(recursion depth)
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        return self.climbStairs(n - 2) + self.climbStairs(n - 1)
+
+
+# 2) Recursion (memoization)
+# Time O(n)
+# Space O(n)
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        dic = [None] * (n + 1)
+
+        def go(i):
+            if i == 1:
+                return 1
+            if i == 2:
+                return 2
+            if dic[i] is not None:
+                return dic[i]
+            dic[i] = go(i - 2) + go(i - 1)
+            return dic[i]
+
+        return go(n)
+
+
+# 3) Dynamic programming - Fibonacci
+# Similar
+# 70. Climbing Stairs
+# 91. Decode Ways
+#
+# Time O(n)
+# Space O(n)
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        dp = [None] * (n + 1)
+        dp[1] = 1
+        dp[2] = 2
+        for i in range(3, n + 1):
+            dp[i] = dp[i - 2] + dp[i - 1]
+        return dp[-1]
+
+
+# 4) Dynamic programming - Fibonacci (optimization)
+# Time O(n)
+# Space O(1)
+class Solution:
+    def climbStairs(self, n: int) -> int:
+        if n == 1:
+            return 1
+        if n == 2:
+            return 2
+        a = 1
+        b = 2
+        for i in range(3, n + 1):
+            c = a + b
+            a = b
+            b = c
+        return c