@@ -0,0 +1,33 @@
+class Solution:
+def threeSum(self, nums: List[int]) -> List[List[int]]:
+if len(nums) < 3: return []
+
+triplets = []
+nums.sort()
+
+for i in range(len(nums)):
+if i > 0 and nums[i] == nums[i-1]:
+continue
+self.twoSum(nums, i+1, -nums[i], triplets)
+
+return triplets
+
+def twoSum(self, nums, l, target, 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,61 @@
+class Solution:
+def setZeroes(self, matrix: List[List[int]]) -> None:
+"""
+Do not return anything, modify matrix in-place instead.
+"""
+ROWS = len(matrix)
+COLS = len(matrix[0])
+
+first_row_zero = False
+for col in range(COLS):
+if matrix[0][col] == 0:
+first_row_zero = True
+
+for row in range(ROWS):
+for col in range(COLS):
+if matrix[row][col] == 0:
+matrix[0][col] = 0
+
+for row in range(1, ROWS):
+row_has_zero = False
+for col in range(COLS):
+if matrix[row][col] == 0:
+row_has_zero = True
+break
+for col in range(COLS):
+if row_has_zero or matrix[0][col] == 0:
+matrix[row][col] = 0
+
+if first_row_zero:
+for col in range(COLS):
+matrix[0][col] = 0
+
+class Solution2:
+def setZeroes(self, matrix: List[List[int]]) -> None:
+"""
+Do not return anything, modify matrix in-place instead.
+"""
+col_has_zero = False
+R = len(matrix)
+C = len(matrix[0])
+
+for i in range(R):
+if matrix[i][0] == 0:
+col_has_zero = True
+for j in range(1, C):
+if matrix[i][j] == 0:
+matrix[0][j] = 0
+matrix[i][0] = 0
+
+for i in range(1, R):
+for j in range(1, C):
+if not matrix[i][0] or not matrix[0][j]:
+matrix[i][j] = 0
+
+if matrix[0][0] == 0:
+for j in range(C):
+matrix[0][j] = 0
+
+if col_has_zero:
+for i in range(R):
+matrix[i][0] = 0

@@ -0,0 +1,12 @@
+from collections import defaultdict
+
+class Solution:
+def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+groups = defaultdict(list)
+
+for word in strs:
+key = ''.join(sorted(word))
+groups[key].append(word)
+
+return groups.values()
+

@@ -0,0 +1,34 @@
+class Solution:
+def lengthOfLongestSubstring(self, s: str) -> int:
+char_idx = {}
+max_len = 0
+l = 0
+
+for r in range(len(s)):
+char = s[r]
+
+if char in char_idx:
+l = max(l, char_idx[char] + 1)
+
+char_idx[char] = r
+max_len = max(max_len, r - l + 1)
+
+return max_len
+
+class Solution2:
+def lengthOfLongestSubstring(self, s: str) -> int:
+if len(s) == 0: return 0
+
+seen = {}
+l = max_len = 0
+
+for r,val in enumerate(s):
+if val in seen and l <= seen[val]:
+l = seen[val] + 1
+else:
+max_len = max(max_len, r - l + 1)
+
+seen[val] = r
+
+return max_len
+

@@ -0,0 +1,35 @@
+class Solution:
+def longestPalindrome(self, s: str) -> str:
+n = len(s)
+l, r = 0, 0 # start and end index of current longest substring
+dp = [[False] * n for _ in range(n)]
+
+# set all 1 letter strings to True
+for i in range(n):
+dp[i][i] = True
+
+# set 2 letter palindromes
+for i in range(n - 1):
+if s[i] == s[i + 1]:
+dp[i][i + 1] = True
+if l == 0 and r == 0:
+l, r = i, i + 1
+
+# set 3+ letter palindromes
+for i in range(2, n):
+for j in range(n - 2):
+k = i + j
+# dp matrix boundary check
+if k == n:
+break
+# check if substring is palindrome
+# cond 1: first and last letter is same
+# cond 2: substring (dp[j + 1][k - 1]) is a palindrome
+if s[j] == s[k] and dp[j + 1][k - 1]:
+dp[j][k] = True
+# set longest substring
+# length of substring(j, k) > length of substring(l, r)
+if k - j > r - l:
+l, r = j, k
+
+return s[l:r + 1]

@@ -0,0 +1,37 @@
+class Solution:
+def increasingTriplet(self, nums: List[int]) -> bool:
+n = len(nums)
+
+left_min = [float('inf')] * n
+left_min[0] = nums[0]
+right_max = [float('-inf')] * n
+right_max[-1] = nums[-1]
+
+for i in range(1, n):
+left_min[i] = min(left_min[i-1], nums[i])
+
+for i in range(n-2, -1, -1):
+right_max[i] = max(right_max[i+1], nums[i])
+
+for i in range(n):
+if left_min[i] < nums[i] < right_max[i]:
+return True
+
+return False
+
+class Solution2:
+def increasingTriplet(self, nums: List[int]) -> bool:
+if len(nums) < 3: return False
+
+first = float('inf')
+second = float('inf')
+
+for num in nums:
+if num <= first:
+first = num
+elif num <= second:
+second = num
+else:
+return True
+
+return False