@@ -0,0 +1,14 @@
+class Solution:
+def twoSum(self, numbers, target):
+l = 0
+r = len(numbers) - 1
+
+while l < r:
+cur_sum = numbers[l] + numbers[r]
+
+if cur_sum == target:
+return [l+1, r+1]
+elif cur_sum > target:
+r -= 1
+else:
+l += 1

@@ -0,0 +1,10 @@
+class Solution:
+def removeDuplicates(self, nums):
+l = 0
+
+for r in range(1, len(nums)):
+if nums[l] != nums[r]:
+l += 1
+nums[l] = nums[r]
+
+return l + 1

@@ -0,0 +1,21 @@
+class Solution:
+def sortedSquares(self, A):
+res = [0] * len(A)
+max_idx = len(res) - 1
+l = 0
+r = max_idx
+
+while l <= r:
+num_l = A[l] ** 2
+num_r = A[r] ** 2
+
+if num_l > num_r:
+res[max_idx] = num_l
+l += 1
+else:
+res[max_idx] = num_r
+r -= 1
+
+max_idx -= 1
+
+return res

@@ -0,0 +1,30 @@
+class Solution:
+def threeSum(self, nums):
+triplets = []
+nums.sort()
+for i in range(len(nums)):
+if i > 0 and nums[i] == nums[i-1]:
+continue
+self.findPair(nums, -nums[i], i+1, triplets)
+return triplets
+
+
+def findPair(self, nums, target, l, triplets):
+r = len(nums) - 1
+
+while l < r:
+cur_sum = nums[l] + nums[r]
+
+if cur_sum == target:
+triplets.append([-target, nums[l], nums[r]])
+l += 1
+r -= 1
+while l < r and nums[l] == nums[l-1]:
+l += 1
+while l < r and nums[r] == nums[r+1]:
+r -= 1
+elif cur_sum > target:
+r -= 1
+else:
+l += 1
+

@@ -0,0 +1,48 @@
+class Solution:
+def threeSumClosest(self, nums, target):
+nums.sort()
+smallest_diff = float('inf')
+
+for i in range(len(nums)-2):
+l = i + 1
+r = len(nums) - 1
+while l < r:
+cur_sum = nums[i] + nums[l] + nums[r]
+cur_diff = target - cur_sum
+
+if cur_diff == 0:
+return cur_sum
+elif cur_diff > 0:
+l += 1
+else:
+r -= 1
+
+if abs(cur_diff) < abs(smallest_diff):
+smallest_diff = cur_diff
+
+return target - smallest_diff
+
+class Solution2:
+def threeSumClosest(self, nums, target):
+nums.sort()
+cur_closest_sum = nums[0] + nums[1] + nums[2]
+
+for i in range(len(nums)-2):
+l = i + 1
+r = len(nums) - 1
+while l < r:
+cur_sum = nums[i] + nums[l] + nums[r]
+old_diff = abs(cur_closest_sum - target)
+new_diff = abs(cur_sum - target)
+
+if new_diff < old_diff:
+cur_closest_sum = cur_sum
+
+if cur_sum > target:
+r -= 1
+elif cur_sum < target:
+l += 1
+else:
+return cur_closest_sum
+
+return cur_closest_sum

@@ -0,0 +1,18 @@
+class Solution:
+def threeSumSmaller(self, nums, target):
+nums.sort()
+count = 0
+
+for i in range(len(nums)-2):
+l = i + 1
+r = len(nums) - 1
+
+while l < r:
+cur_sum = nums[i] + nums[l] + nums[r]
+if cur_sum >= target:
+r -= 1
+else:
+count += r - l
+l += 1
+
+return count

@@ -0,0 +1,15 @@
+class Solution:
+def numSubarrayProductLessThanK(self, nums, k):
+count = 0
+product = 1
+window_start = 0
+
+for window_end in range(len(nums)):
+product *= nums[window_end]
+while window_start < window_end and product >= k:
+product /= nums[window_start]
+window_start += 1
+if product < k:
+count += window_end - window_start + 1
+
+return count

@@ -0,0 +1,20 @@
+class Solution:
+def sortColors(self, nums):
+"""
+Do not return anything, modify nums in-place instead.
+"""
+low = 0
+high = len(nums) - 1
+
+i = 0
+while i < len(nums):
+if nums[i] == 0:
+nums[i], nums[low] = nums[low], nums[i]
+low += 1
+i += 1
+elif nums[i] == 2:
+nums[i], nums[high] = nums[high], nums[i]
+high -= 1
+else:
+i += 1
+