Merge pull request #20 from tiationg-kho/update

update

Author: tiationg-kho

README.md

@@ -0,0 +1,16 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        res = 0
+        left, right = 0, len(height) - 1
+        while left < right:
+            if height[left] < height[right]:
+                res = max(res, height[left] * (right - left))
+                left += 1
+            else:
+                res = max(res, height[right] * (right - left))
+                right -= 1
+        return res
+    
+# time O(n)
+# space O(1)
+# using array and two pointers opposite direction and shrink type and greedy

[H]array/[H]array-two-pointers-opposite-direction/11-container-with-most-water.py

@@ -0,0 +1,18 @@
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        left, right = 0, len(s) - 1
+        while left < right:
+            if not s[left].isalnum():
+                left += 1
+            elif not s[right].isalnum():
+                right -= 1
+            elif s[left].lower() == s[right].lower():
+                left += 1
+                right -= 1
+            else:
+                return False
+        return True
+    
+# time O(n), due to traverse
+# space O(1)
+# using array and two pointers opposite direction and shrink type

[H]array/[H]array-two-pointers-opposite-direction/125-valid-palindrome.py

@@ -0,0 +1,34 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+
+        nums.sort()
+
+        res = []
+        for i in range(len(nums) - 2):
+            if i - 1 >= 0 and nums[i - 1] == nums[i]:
+                continue
+            left, right = i + 1, len(nums) - 1
+            target = - nums[i]
+            while left < right:
+                cur = nums[left] + nums[right]
+                if cur == target:
+                    res.append([nums[i], nums[left], nums[right]])
+                    left += 1
+                    while left < right and nums[left - 1] == nums[left]:
+                        left += 1
+                elif cur > target:
+                    right -= 1
+                    while left < right and nums[right + 1] == nums[right]:
+                        right -= 1
+                else:
+                    left += 1
+                    while left < right and nums[left - 1] == nums[left]:
+                        left += 1
+        return res
+    
+# time O(n**2)
+# space O(1), or due to built in sort's cost
+# using array and two pointers opposite direction and shrink type and sort
+'''
+1. be aware of handling duplicate
+'''

[H]array/[H]array-two-pointers-opposite-direction/15-3sum.py

@@ -0,0 +1,34 @@
+class Solution:
+    def reverseWords(self, s: str) -> str:
+
+        chars = list(' ' + s + ' ')
+
+        def rev(left, right):
+            while left < right:
+                chars[left], chars[right] = chars[right], chars[left]
+                left += 1
+                right -= 1
+        
+        rev(0, len(chars) - 1)
+
+        word = False
+        left = 0
+        for right in range(len(chars)):
+            if chars[right] == ' ' and word:
+                rev(left, right)
+                word = False
+            elif chars[right] != ' ' and not word:
+                left = right
+                word = True
+        
+        res = ''
+        for c in chars:
+            if c != ' ':
+                res += c
+            elif res and res[- 1] != ' ':
+                res += ' '
+        return res.rstrip()
+
+# time O(n)
+# space O(n)
+# using array and two pointers opposite direction and shrink type

[H]array/[H]array-two-pointers-opposite-direction/151-reverse-words-in-a-string.py

@@ -0,0 +1,39 @@
+class Solution:
+    def threeSumClosest(self, nums: List[int], target: int) -> int:
+
+        nums.sort()
+        res_diff = float('inf')
+        res = None
+
+        for i in range(len(nums) - 2):
+            left, right = i + 1, len(nums) - 1
+            
+            small_three = nums[i] + nums[left] + nums[left + 1]
+            if small_three > target:
+                if abs(small_three - target) < res_diff:
+                    res_diff = abs(small_three - target)
+                    res = small_three
+                break
+            large_three = nums[i] + nums[right - 1] + nums[right]
+            if large_three < target:
+                if abs(large_three - target) < res_diff:
+                    res_diff = abs(large_three - target)
+                    res = large_three
+                continue
+            
+            while left < right:
+                cur = nums[i] + nums[left] + nums[right]
+                if abs(cur - target) < res_diff:
+                    res_diff = abs(cur - target)
+                    res = cur
+                if cur == target:
+                    return target
+                elif cur > target:
+                    right -= 1
+                else:
+                    left += 1
+        return res
+
+# time O(n**2)
+# space O(1), not count built in sort's cost
+# using array and two pointers opposite direction and shrink type and sort and prune

[H]array/[H]array-two-pointers-opposite-direction/16-3sum-closest.py

@@ -0,0 +1,15 @@
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        left, right = 0, len(numbers) - 1
+        while left < right:
+            if numbers[left] + numbers[right] == target:
+                break
+            elif numbers[left] + numbers[right] > target:
+                right -= 1
+            else:
+                left += 1
+        return [left + 1, right + 1]
+
+# time O(n), due to traverse
+# space O(1)
+# using array and two pointers opposite direction and shrink type

[H]array/[H]array-two-pointers-opposite-direction/167-two-sum-ii-input-array-is-sorted.py

@@ -0,0 +1,31 @@
+class Solution:
+    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        nums.sort()
+        res = []
+        for i in range(len(nums) - 3):
+            if i - 1 >= 0 and nums[i - 1] == nums[i]:
+                continue
+            for j in range(i + 1, len(nums) - 2):
+                if j - 1 >= i + 1 and nums[j - 1] == nums[j]:
+                    continue
+                left, right = j + 1, len(nums) - 1
+                while left < right:
+                    cur = nums[i] + nums[j] + nums[left] + nums[right]
+                    if cur == target:
+                        res.append([nums[i], nums[j], nums[left], nums[right]])
+                        left += 1
+                        while left < right and nums[left - 1] == nums[left]:
+                            left += 1
+                    elif cur > target:
+                        right -= 1
+                        while left < right and nums[right + 1] == nums[right]:
+                            right -= 1
+                    else:
+                        left += 1
+                        while left < right and nums[left - 1] == nums[left]:
+                            left += 1
+        return res
+    
+# time O(n**3)
+# space O(1), not count output list
+# using array and two pointers opposite direction and shrink type and sort

[H]array/[H]array-two-pointers-opposite-direction/18-4sum.py

@@ -0,0 +1,14 @@
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
+        """
+        Do not return anything, modify s in-place instead.
+        """
+        left, right = 0, len(s) - 1
+        while left < right:
+            s[left], s[right] = s[right], s[left]
+            left += 1
+            right -= 1
+
+# time O(n)
+# space O(1)
+# using array and two pointers opposite direction and shrink type

[H]array/[H]array-two-pointers-opposite-direction/344-reverse-string.py

@@ -0,0 +1,22 @@
+class Solution:
+    def trap(self, height: List[int]) -> int:
+        res = 0
+        left, right = 0, len(height) - 1
+        left_wall, right_wall = height[left], height[right]
+        while left < right:
+            left_wall = max(left_wall, height[left])
+            right_wall = max(right_wall, height[right])
+            if left_wall < right_wall:
+                res += left_wall - height[left]
+                left += 1
+            else:
+                res += right_wall - height[right]
+                right -= 1
+        return res
+        
+# tiem O(n), due to traverse
+# space O(1)
+# using array and two pointers opposite direction and shrink type and greedy
+'''
+1. count the water with lower wall's side first
+'''

[H]array/[H]array-two-pointers-opposite-direction/42-trapping-rain-water.py

@@ -0,0 +1,35 @@
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+
+        res_len = 0
+        res = - 1
+        
+        for i in range(len(s)):
+
+            left, right = i, i
+            while left >= 0 and right < len(s):
+                if s[left] == s[right]:
+                    if right - left + 1 > res_len:
+                        res_len = right - left + 1
+                        res = left
+                    left -= 1
+                    right += 1
+                else:
+                    break
+            
+            left, right = i, i + 1
+            while left >= 0 and right < len(s):
+                if s[left] == s[right]:
+                    if right - left + 1 > res_len:
+                        res_len = right - left + 1
+                        res = left
+                    left -= 1
+                    right += 1
+                else:
+                    break
+            
+        return s[res: res + res_len]
+
+# time O(n**2), traversal costs O(n), and each time need to using two pointers to expand
+# space O(1)
+# using array and two pointers opposite direction and expand type

[H]array/[H]array-two-pointers-opposite-direction/5-longest-palindromic-substring.py

@@ -0,0 +1,18 @@
+class Solution:
+    def validPalindrome(self, s: str) -> bool:
+        
+        def helper(left, right, count):
+            while left < right:
+                if s[left] != s[right]:
+                    if count == 0:
+                        return helper(left + 1, right, 1) or helper(left, right - 1, 1)
+                    return False
+                left += 1
+                right -= 1
+            return True
+
+        return helper(0, len(s) - 1, 0)
+
+# time O(n), due to traverse
+# space O(1)
+# using array and two pointers opposite direction and shrink type

[H]array/[H]array-two-pointers-opposite-direction/680-valid-palindrome-ii.py

@@ -0,0 +1,25 @@
+class Solution:
+    def bagOfTokensScore(self, tokens: List[int], power: int) -> int:
+
+        tokens.sort()
+
+        res = 0
+        score = 0
+        left, right = 0, len(tokens) - 1
+        while left <= right:
+            if power >= tokens[left]:
+                power -= tokens[left]
+                score += 1
+                left += 1
+                res = max(res, score)
+            elif score >= 1:
+                power += tokens[right]
+                score -= 1
+                right -= 1
+            else:
+                break
+        return res
+        
+# time O(nlogn)
+# space O(1), or due to built in sort
+# using array and two pointers opposite direction and shrink type and sort and greedy

[H]array/[H]array-two-pointers-opposite-direction/948-bag-of-tokens.py

@@ -0,0 +1,16 @@
+class Solution:
+    def sortedSquares(self, nums: List[int]) -> List[int]:
+        res = []
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            if nums[left] ** 2 < nums[right] ** 2:
+                res.append(nums[right] ** 2)
+                right -= 1
+            else:
+                res.append(nums[left] ** 2)
+                left += 1
+        return res[:: - 1]
+        
+# time O(n)
+# space O(n)
+# using array and two pointers opposite direction and shrink type

[H]array/[H]array-two-pointers-opposite-direction/977-squares-of-a-sorted-array.py

@@ -353,7 +353,7 @@ two pointers opposite direction
     - could use the attribute of sorted order
     - if not sorted
         - we should greedily think move which side’s ptr will be the current best choice
-        - or think which side’s ptr’s result is already the final result
+        - or consider which side’s ptr’s result is already the final result
             - record it if need, then move this side’s ptr
         - or the both side shrink together
             - sometimes can use when we want to reverse array
@@ -429,7 +429,7 @@ two pointers opposite direction
             quick_sort(0, len(nums) - 1)
             return nums
 
-    # time O(n**2), when the list is almost sorted, and the average time is O(nlogn)
+    # time O(n**2), worst-case happens due to bad pivot choice or nearly sorted array, and the average time is O(nlogn)
     # space O(n), due to recursion layers, O(logn) in average
     # using quick sort
     # unstable