Initial commit

Author: danyal-s

Diff for: 110_balanced-binary-tree.py

@@ -0,0 +1,31 @@
+# https://leetcode.com/problems/balanced-binary-tree/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+
+from collections import deque
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        is_balanced = True
+        
+        def dfs(root):
+            nonlocal is_balanced
+            
+            if root is None:
+                return 0
+            
+            left = dfs(root.left)
+            right = dfs(root.right)
+            
+            if abs(left - right) > 1:
+                is_balanced = False
+            
+            return max(left, right) + 1
+            
+
+        dfs(root)
+        return is_balanced

Diff for: 121_best-time-to-buy-and-sell-stock.py

@@ -0,0 +1,12 @@
+# https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+import sys
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        min_price = sys.maxsize
+        res = 0
+        
+        for p in prices:
+            min_price = min(p, min_price)
+            res = max(res, p - min_price)
+            
+        return res

Diff for: 125_valid-palindrome.py

@@ -0,0 +1,16 @@
+# https://leetcode.com/problems/valid-palindrome/
+import re
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        s = s.lower()
+        s = "".join(re.findall("[A-Za-z0-9]", s))
+        i, j = 0, len(s) - 1
+        
+        while i < j:
+            if s[i] != s[j]:
+                return False
+            
+            i += 1
+            j -= 1
+            
+        return True

Diff for: 141_linked-list-cycle.py

@@ -0,0 +1,46 @@
+# https://leetcode.com/problems/linked-list-cycle/
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        if head is None:
+            return False
+        
+        #O(n^2) time, O(1) space
+        cur_node = head
+        cur_node_delayed = head
+        
+        if cur_node.next is None:
+            return False
+        
+        if cur_node.next.next is None:
+            return False
+        
+
+        while cur_node.next is not None and cur_node.next.next is not None:
+            cur_node = cur_node.next.next
+            cur_node_delayed = cur_node_delayed.next
+            
+            if cur_node == cur_node_delayed:
+                return True
+        
+        return False
+
+
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        # O(n) time, O(n) space
+        n_addresses = set()
+        
+        cur_node = head
+        while cur_node.next is not None:
+            if id(cur_node) in n_addresses:
+                return True
+            n_addresses.add(id(cur_node))
+            cur_node = cur_node.next
+        
+        return False

Diff for: 1_two_sum.py

@@ -0,0 +1,42 @@
+# https://leetcode.com/problems/two-sum/
+
+class Solution:
+    def twoSumBruteForce(self, nums: List[int], target: int) -> List[int]:
+        """O(n^2) with O(1) space"""
+        for i in range(0, len(nums)):
+            for j in range(i+1, len(nums)):
+                if nums[i] + nums[j] == target:
+                    return i, j
+        
+    def twoSumFaster(self, nums: List[int], target: int) -> List[int]:
+        """O(nlogn) with O(n) space"""
+        
+        i, j = 0, len(nums) - 1
+        
+        nums2 = [(x, i) for i, x in enumerate(nums)]
+        nums2.sort(key=lambda x: x[0])
+        
+        ij_sum = nums2[i][0] + nums2[j][0]
+        while ij_sum != target:
+            
+            if ij_sum > target:
+                j-=1
+            else:
+                i+=1
+                
+            ij_sum = nums2[i][0] + nums2[j][0]
+        
+        return nums2[i][1], nums2[j][1]
+
+        
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        """
+        O(n) w/ O(n) space - most optimal and simplest logic
+        """
+        # Visited values as dict keys with their indexes as dict values
+        visited_values = {}
+        for i, x in enumerate(nums):
+            if (target - x) in visited_values.keys():
+                return i, visited_values[target - x]
+            else:
+                visited_values[x] = i

Diff for: 20_valid_parantheses.py

@@ -0,0 +1,27 @@
+# https://leetcode.com/problems/valid-parentheses/
+
+from collections import deque
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = deque()
+        for c in s:
+            if c in "([{":
+                stack.append(c)
+            
+            if c in ")]}":
+                if len(stack) == 0:
+                    return False
+                
+                opening_bracket = stack.pop()
+
+                if opening_bracket == "(":
+                    expected_closing_bracket = ")"
+                elif opening_bracket == "[":
+                    expected_closing_bracket = "]"
+                else:
+                    expected_closing_bracket = "}"
+                    
+                if c != expected_closing_bracket:
+                    return False
+
+        return True if len(stack) == 0 else False

Diff for: 21_merge_two_sorted_lists.py

@@ -0,0 +1,39 @@
+# https://leetcode.com/problems/merge-two-sorted-lists/
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        if list1 is None or list2 is None:
+            if list1 is not None:
+                return list1
+            
+            if list2 is not None:
+                return list2
+            
+            return None
+        
+        l1_p = list1
+        l2_p = list2
+        res_head = list2 if l1_p.val >= l2_p.val else list1
+        
+        while l1_p and l2_p:
+            if l1_p.val >= l2_p.val:
+
+                while l2_p.next is not None and l1_p.val >= l2_p.next.val:
+                    l2_p = l2_p.next
+                
+                l2_p.next, l2_p = l1_p, l2_p.next
+
+            else:
+    
+                while l1_p.next is not None and l2_p.val >= l1_p.next.val:
+                    l1_p = l1_p.next
+                
+                l1_p.next, l1_p = l2_p, l1_p.next
+
+        
+        return res_head

Diff for: 226_invert_binary_tree.py

@@ -0,0 +1,19 @@
+# https://leetcode.com/problems/invert-binary-tree/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+        if root is None:
+            return None
+        
+        root.left, root.right = root.right, root.left
+        
+        self.invertTree(root.left)
+        self.invertTree(root.right)
+        
+        return root

Diff for: 235_lowest-common-ancestor-of-a-binary-search-tree.py

@@ -0,0 +1,14 @@
+# https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-search-tree/
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        if p.val > root.val and q.val > root.val: return self.lowestCommonAncestor(root.right, p, q)
+        elif p.val < root.val and q.val < root.val: return self.lowestCommonAncestor(root.left, p, q)
+        else: return root

Diff for: 242_valid_anagram.py

@@ -0,0 +1,12 @@
+# https://leetcode.com/problems/valid-anagram/
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        chars = [0]*26
+        
+        for c in s:
+            chars[ord(c) - ord("a")] += 1
+        
+        for c in t:
+            chars[ord(c) - ord("a")] -= 1
+            
+        return all(c == 0 for c in chars)

Diff for: 53_maximum_subarray.py

@@ -0,0 +1,21 @@
+# https://leetcode.com/problems/maximum-subarray/
+
+class Solution:
+    def maxSubArrayNTime(self, nums: List[int]) -> int:
+        cur = -10001
+        max_res = -10001
+        for num in nums:
+            cur = max(num, num + cur)
+            max_res = max(cur, max_res)
+        return max_res
+            
+    
+    def maxSubArray(self, nums: List[int]) -> int:
+        if len(nums) == 1:
+            return nums
+            
+        l = self.maxSubArray(nums[:len(nums)//2])
+        r = self.maxSubArray(nums[len(nums)//2:])
+        
+        return max(r, l+r)
+            

Diff for: 704_binary_search.go

@@ -0,0 +1,32 @@
+# https://leetcode.com/problems/binary-search/
+
+func search(nums []int, target int) int {
+
+    if len(nums) == 0 {
+        return -1
+    }
+
+    start_index := 0
+    end_index := len(nums) - 1
+    mid_index := ((end_index - start_index) / 2) + start_index
+    
+    for start_index != end_index && start_index < len(nums) && end_index >= 0 {
+        if target == nums[mid_index] {
+            return mid_index
+        }
+        if target < nums[mid_index]{
+            end_index = mid_index - 1
+        } else {
+            start_index = mid_index + 1
+        }
+        mid_index = ((end_index - start_index) / 2) + start_index
+    }
+    
+    if start_index < len(nums) && end_index >= 0 && target == nums[mid_index] {
+        return start_index
+    }
+    
+    return -1
+    
+    
+}

Diff for: 733_flood_fill.py

@@ -0,0 +1,21 @@
+class Solution:
+    def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:
+        if color == image[sr][sc] or len(image) == 0 or len(image[0]) == 0:
+            return image
+        
+        image_pixel = image[sr][sc]
+        image[sr][sc] = color
+
+        if sr - 1 >= 0 and image[sr - 1][sc] == image_pixel:
+            self.floodFill(image, sr - 1, sc, color)
+        
+        if sr + 1 < len(image) and image[sr + 1][sc] == image_pixel:
+            self.floodFill(image, sr + 1, sc, color)
+        
+        if sc - 1 >= 0 and image[sr][sc - 1] == image_pixel:
+            self.floodFill(image, sr, sc - 1, color)
+        
+        if sc + 1 < len(image[0]) and image[sr][sc + 1] == image_pixel:
+            self.floodFill(image, sr, sc + 1, color)
+
+        return image