feat(python): solutions

Author: hongbo-miao

JavaScript/0005. Longest Palindromic Substring.js

@@ -40,7 +40,7 @@
 // This yields a straight forward DP solution, which we first initialize the one and two letters palindromes, and work
 // our way up finding all three letters palindromes, and so on.
 
-/** 3) Expand around center */
+/** 3) Expand from center */
 // https://www.youtube.com/watch?v=m2Mk9JN5T4A
 //
 // Time O(n^2). Expanding a palindrome around its center takes O(n) time, so the overall complexity is O(n^2)

JavaScript/0010. Regular Expression Matching.js

@@ -147,7 +147,7 @@ const isMatch3 = (s, p) => {
 };
 
 /** 4) Dynamic programming */
-// https://www.youtube.com/watch?v=qza1UKNHAys
+// https://leetcode.com/problems/regular-expression-matching/discuss/5651/Easy-DP-Java-Solution-with-detailed-Explanation/238767
 //
 // dp[i][j] denotes whether s[0 : i - 1] matches p[0 : j - 1]
 //
@@ -157,47 +157,54 @@ const isMatch3 = (s, p) => {
 // 2. if p[j] === '.'
 //    dp[i][j] = dp[i - 1][j - 1]
 //
-// 3. if p[j] === '*'
+// 3. if p[j] === '*', also need consider p[j - 1]
 //    1) if p[j - 1] !== s[i] and p[j - 1] !== '.'  // a ab* and not a a.*
 //       dp[i][j] = dp[i][j - 2]                    // e.g. a ab* -> p remove 'b*' which is j - 2
 //
-//    2) if p[i - 1] === s[i] or p[i - 1] == '.'
-//       a) dp[i][j] = dp[i][j - 2]                 // c* - empty, e.g. ab ab.*
-//       b) dp[i][j] = dp[i][j - 1]                 // c* - single c, e.g. abc abc*
-//       c) dp[i][j] = dp[i - 1][j]                 // c* - multiple c, e.g. abccc abc*
+//    2) if p[j - 1] === s[i] or p[j - 1] === '.'
+//       a) dp[i][j] = dp[i][j - 2]                 // c* - no 'c', e.g. ab ab.*
+//       b) dp[i][j] = dp[i][j - 1]                 // c* - single 'c', e.g. abc abc*
+//       c) dp[i][j] = dp[i - 1][j]                 // c* - multiple 'c', e.g. abccc abc*
 //
 // Example 1
 // s = 'abcd', p = 'a*.cd'
 //
-//       p 0 1 2 3 4
-//       0 1 2 3 4 5
-// s 0     a * . c d
-// 0 1   T F T F F F
-// 1 2 a F T T T F F
-// 2 3 b F F F T F F
-// 3 4 c F F F F T F
-// 4 5 d F F F F F T
+//     p 0 1 2 3 4
+// s     a * . c d
+// 0   T F T F F F
+// 1 a F T T T F F
+// 2 b F F F T F F
+// 3 c F F F F T F
+// 4 d F F F F F T
 //
 // Example 2
 // s = 'abaa', p = 'ab.*'
 //
-//     p 0 1 2 3 4
-//     0 1 2 3 4 5
-// s 0     a b . *
-// 0 1   T F F F F
-// 1 2 a F T F F F
-// 2 3 b F F T F T
-// 3 4 a F F F T T
-// 4 5 a F F F F T
+//   p 0 1 2 3 4
+// s     a b . *
+// 0   T F F F F
+// 1 a F T F F F
+// 2 b F F T F T
+// 3 a F F F T T
+// 4 a F F F F T
 
 const isMatch = (s, p) => {
   const dp = [...Array(s.length + 1)].map(() => Array(p.length + 1).fill(false));
+
+  // Initialization
+  // 1) empty string matches empty pattern
   dp[0][0] = true;
 
-  // init dp[0][i] to true if p[i] is *
-  for (let i = 1; i < p.length; i++) {
-    if (p[i] === '*' && dp[0][i - 1]) {
-      dp[0][i + 1] = true;
+  // 2) dp[i][0] = false (which is default value of the boolean array) since empty pattern cannot match non-empty string
+  // 3) dp[0][j]: what pattern matches empty string ""? It should be #*#*#*#*..., or (#*)* if allow me to represent regex using regex :P,
+  //    and for this case we need to check manually:
+  //    as we can see, the length of pattern should be even && the character at the even position should be *,
+  //    thus for odd length, dp[0][j] = false which is default. So we can just skip the odd position, i.e. j starts from 2, the interval of j is also 2.
+  //    and notice that the length of repeat sub-pattern #* is only 2, we can just make use of dp[0][j - 2] rather than scanning j length each time
+  //    for checking if it matches #*#*#*#*.
+  for (let j = 2; j < p.length; j += 2) {
+    if (p[j - 1] === '*' && dp[0][j - 2]) {
+      dp[0][j] = true;
     }
   }
 

Python/0003. Longest Substring Without Repeating Characters.py

@@ -0,0 +1,82 @@
+# Given a string s, find the length of the longest substring without repeating characters.
+#
+# Example 1:
+#
+# Input: s = "abcabcbb"
+# Output: 3
+# Explanation: The answer is "abc", with the length of 3.
+#
+# Example 2:
+#
+# Input: s = "bbbbb"
+# Output: 1
+# Explanation: The answer is "b", with the length of 1.
+#
+# Example 3:
+#
+# Input: s = "pwwkew"
+# Output: 3
+# Explanation: The answer is "wke", with the length of 3.
+# Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.
+#
+# Constraints:
+#
+# 0 <= s.length <= 5 * 10^4
+# s consists of English letters, digits, symbols and spaces.
+
+
+# 1) Sliding window + hash map
+# Similar
+# 3. Longest Substring Without Repeating Characters
+# 904. Fruit Into Baskets
+# 992. Subarrays with K Different Integers
+#
+# Time O(2n) = O(n). In the worst case each character will be visited twice by l and r.
+# Space O(min(m, n)). We need O(k) space for the sliding window, where k is the size of the Set. The size of the Set is
+#   upper bounded by the size of the string nn and the size of the charset/alphabet m.
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        dic = dict()
+        max_len = 0
+        l = 0
+        r = 0
+        while l < len(s) and r < len(s):
+            if s[r] not in dic:
+                dic[s[r]] = True
+                r += 1
+                max_len = max(max_len, r - l)
+            else:
+                dic.pop(s[l])
+                l += 1
+        return max_len
+
+
+# 2) Sliding window (optimized)
+# Time O(n)
+# Space O(min(m, n)), m is the size of the hash map
+#
+# The above solution requires at most 2n steps. In fact, it could be optimized to require only n steps. Instead of
+# using a set to tell if a character exists or not, we could define a mapping of the characters to its index. Then
+# we can skip the characters immediately when we found a repeated character.
+#   The reason is that if s[r] have a duplicate in the range [l, r) with index r', we don't need to increase l
+# little by little. We can skip all the elements in the range [l, r'] and let l to be r' + 1 directly.
+#
+# e.g. pwwkew
+# l = 0, r = 0, dic = { p: 1 }
+# l = 0, r = 1, dic = { p: 1, w: 2 }
+# l = 2, r = 2, dic = { p: 1, w: 3 }
+# l = 2, r = 3, dic = { p: 1, w: 3, k: 4 }
+# l = 2, r = 4, dic = { p: 1, w: 3, k: 4, e: 5 }
+# l = 3, r = 5, dic = { p: 1, w: 6, k: 4, e: 5 }
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        dic = dict()
+        max_len = 0
+        l = 0
+        for r, c in enumerate(s):
+            if c in dic:
+                # not l = dic[c], because max makes sure l always increase
+                l = max(l, dic[c])
+            dic[c] = r + 1  # dic[c] saves next start point for l
+            max_len = max(max_len, r - l)
+        return max_len

Python/0004. Median of Two Sorted Arrays.py

@@ -0,0 +1,42 @@
+# Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays.
+# The overall run time complexity should be O(log (m+n)).
+#
+# Example 1:
+#
+# Input: nums1 = [1,3], nums2 = [2]
+# Output: 2.00000
+# Explanation: merged array = [1,2,3] and median is 2.
+#
+# Example 2:
+#
+# Input: nums1 = [1,2], nums2 = [3,4]
+# Output: 2.50000
+# Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5.
+#
+# Constraints:
+#
+# nums1.length == m
+# nums2.length == n
+# 0 <= m <= 1000
+# 0 <= n <= 1000
+# 1 <= m + n <= 2000
+# -10^6 <= nums1[i], nums2[i] <= 10^6
+
+# 1) Sorting
+# Time O((m + n)log(m + n))
+# Space O(m + n)
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        nums = nums1 + nums2
+        nums.sort()
+        if len(nums) % 2 != 0:
+            return nums[len(nums) // 2]
+        else:
+            return (nums[len(nums) // 2 - 1] + nums[len(nums) // 2]) / 2
+
+
+# Binary Search
+# https://zxi.mytechroad.com/blog/algorithms/binary-search/leetcode-4-median-of-two-sorted-arrays/
+#
+# Time O(log(m + n))
+# Space O(1)

Python/0005. Longest Palindromic Substring.py

@@ -0,0 +1,71 @@
+# Given a string s, return the longest palindromic substring in s.
+#
+# Example 1:
+#
+# Input: s = "babad"
+# Output: "bab"
+# Explanation: "aba" is also a valid answer.
+
+# Example 2:
+#
+# Input: s = "cbbd"
+# Output: "bb"
+#
+# Constraints:
+#
+# 1 <= s.length <= 1000
+# s consist of only digits and English letters.
+
+# 1) Brute force
+# Time O(n^3)
+# Space O(1)
+#
+# Pick all possible starting and ending positions for a substring, and verify if it is a palindrome
+
+# 2) Dynamic programming
+# Time O(n^2)
+# Space O(n^2)
+#
+# To improve over the brute force solution, we first observe how we can avoid unnecessary re-computation while
+# validating palindromes. Consider the case "ababa". If we already knew that "bab" is a palindrome, it is obvious
+# that "ababa" must be a palindrome since the two left and right end letters are the same.
+#
+# Therefore,
+# dp(i, j) = dp(i + 1, j − 1) and s(i) == s(j)
+#
+# The base cases are:
+# dp(i, i) = true
+# dp(i, i + 1) = s(i) == s(j + 1)
+#
+# This yields a straight forward DP solution, which we first initialize the one and two letters palindromes, and work
+# our way up finding all three letters palindromes, and so on.
+
+# 3) Expand from center
+# https://www.youtube.com/watch?v=m2Mk9JN5T4A
+#
+# Time O(n^2). Expanding a palindrome from its center takes O(n) time, so the overall complexity is O(n^2)
+# Space O(1)
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        res = ""
+        for i in range(len(s)):
+            s1 = self.expend_from_center(s, i, i)
+            if len(s1) > len(res):
+                res = s1
+            s2 = self.expend_from_center(s, i, i + 1)
+            if len(s2) > len(res):
+                res = s2
+        return res
+
+    @staticmethod
+    def expend_from_center(s: str, l: int, r: int) -> str:
+        while l >= 0 and r < len(s) and s[l] == s[r]:
+            l -= 1
+            r += 1
+        return s[l + 1 : r]
+
+
+# Manacher's algorithm
+# Time O(n)
+#
+# It is a non-trivial algorithm

Python/0007. Reverse Integer.py

@@ -0,0 +1,48 @@
+# Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.
+# Assume the environment does not allow you to store 64-bit integers (signed or unsigned).
+#
+# Example 1:
+# Input: x = 123
+# Output: 321
+#
+# Example 2:
+# Input: x = -123
+# Output: -321
+#
+# Example 3:
+# Input: x = 120
+# Output: 21
+#
+# Constraints:
+# -2^31 <= x <= 2^31 - 1
+
+
+# Pop and push
+# Time O(n)
+# Space O(1)
+#
+# e.g. 123
+# d: 3, x: 12, n: 3
+# d: 2, x: 1,  n: 32
+# d: 1, x: 0,  n: 321
+class Solution:
+    def reverse(self, x: int) -> int:
+        if x < 0:
+            return -self.reverse(-x)
+
+        n = 0
+        while x > 0:
+            # pop
+            d = x % 10
+            x = x // 10
+
+            # push
+            n = n * 10 + d
+
+            # Above codes can be combined to these, but hard to understand
+            # n = n * 10 + x % 10
+            # x = x // 10
+
+            if n > 2 ** 31 - 1:
+                return 0
+        return n