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
+'''