Add files via upload

rai-abhi24 · web-flow · commit 51801483ae79 · 2024-05-10T12:58:59.000+05:30
diff --git a/Balanced Binary Tree - Leetcode 110.py b/Balanced Binary Tree - Leetcode 110.py
@@ -0,0 +1,21 @@
+class Solution:
+    def isBalanced(self, root: Optional[TreeNode]) -> bool:
+        balanced = [True]
+
+        def height(root):
+            if not root:
+                return 0
+
+            left_height = height(root.left)
+            if balanced[0] is False:
+                return 0
+
+
+            right_height = height(root.right)
+            if abs(left_height - right_height) > 1:
+                balanced[0] = False
+                return 0
+            return 1 + max(left_height, right_height)
+
+        height(root)
+        return balanced[0]
diff --git a/Binary Search - Leetcode 704.py b/Binary Search - Leetcode 704.py
@@ -0,0 +1,16 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        left = 0
+        right = len(nums) - 1
+
+        while left <= right:
+            middle = (right + left) // 2
+
+            if nums[middle] == target:
+                return middle
+            elif nums[middle] > target:
+                right = middle - 1
+            else:
+                left = middle + 1
+
+        return -1
diff --git a/Binary Tree Level Order Traversal (BFS) - Leetcode 102.py b/Binary Tree Level Order Traversal (BFS) - Leetcode 102.py
@@ -0,0 +1,22 @@
+class Solution:
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        if root is None:
+            return None
+        
+        queue = deque()
+        queue.append(root)
+        ans = []
+        
+        while queue:
+            level = []
+            n = len(queue)
+            for i in range(n):
+                node = queue.popleft()
+                level.append(node.val)
+
+                if node.left: queue.append(node.left)                
+                if node.right: queue.append(node.right)
+            
+            ans.append(level)
+
+        return ans
diff --git a/Copy List with Random Pointer - Leetcode 138.py b/Copy List with Random Pointer - Leetcode 138.py
@@ -0,0 +1,22 @@
+class Solution:
+    def copyRandomList(self, head: "Optional [Node]") -> "Optional [Node]":
+        if not head:
+            return None
+
+        curr = head
+        old_to_new = {}
+
+        while curr:
+            node = Node(x=curr.val)
+            old_to_new[curr] = node
+            curr = curr.next
+
+        curr = head
+
+        while curr:
+            new_node = old_to_new[curr]
+            new_node.next = old_to_new[curr.next] if curr.next else None
+            new_node.random = old_to_new[curr.random] if curr.random else None
+            curr = curr.next
+
+        return old_to_new[head]
diff --git a/Count Good Nodes in Binary Tree - Leetcode 1448.py b/Count Good Nodes in Binary Tree - Leetcode 1448.py
@@ -0,0 +1,16 @@
+class Solution:
+    def goodNodes(self, root: TreeNode) -> int:
+        good_nodes = 0
+        stk = [(root, float("-inf"))]
+
+        while stk:
+            node, largest = stk.pop()
+            
+            if largest <= node.val:
+                good_nodes += 1
+
+            largest = max(largest, node.val)
+            if node.right: stk.append((node.right, largest))
+            if node.left: stk.append((node.left, largest))
+
+        return good_nodes
diff --git a/Diameter of Binary Tree - Leetcode 543.py b/Diameter of Binary Tree - Leetcode 543.py
@@ -0,0 +1,18 @@
+class Solution:
+    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        largest_diameter = [0]
+
+        def height(root):
+            if root is None:
+                return 0
+
+            left_height = height(root.left)
+            right_height = height(root.right)
+            diameter = left_height + right_height
+
+            largest_diameter[0] = max(largest_diameter[0], diameter)
+            
+            return 1 + max(left_height, right_height)
+
+        height(root)
+        return largest_diameter[0]
diff --git a/Find Minimum in Rotated Sorted Array - Leetcode 153.py b/Find Minimum in Rotated Sorted Array - Leetcode 153.py
@@ -0,0 +1,15 @@
+class Solution:
+    def findMin(self, nums: List[int]) -> int:
+        n = len(nums)
+        l = 0
+        r = n - 1
+
+        while l < r:
+            m = (l + r) // 2
+        
+            if nums[m] > nums[r]:
+                l = m + 1
+            else:
+                r = m
+
+        return nums[l]
diff --git a/Insert GCDs in Linked List - Leetcode 2807.py b/Insert GCDs in Linked List - Leetcode 2807.py
@@ -0,0 +1,13 @@
+class Solution:
+    def insertGreatestCommonDivisors(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        prev = head
+        cur = head.next
+        
+        while cur:
+            gcd = math.gcd(cur.val, prev.val)
+            g = ListNode(gcd)
+            prev.next = g
+            g.next = cur
+            prev = cur
+            cur = cur.next
+        return head
diff --git a/Invert Binary Tree - Leetcode 226.py b/Invert Binary Tree - Leetcode 226.py
@@ -0,0 +1,12 @@
+class Solution:
+    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
+
+        if not root:
+            return None
+
+        root.left, root.right = root.right, root.left
+
+        self.invertTree(root.left)
+        self.invertTree(root.right)
+
+        return root
diff --git a/K Closest Points to Origin - Leetcode 973.py b/K Closest Points to Origin - Leetcode 973.py
@@ -0,0 +1,14 @@
+class Solution:
+    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
+        def dist(x, y):
+            return x**2 + y**2
+
+        heap = []
+        for x, y in points:
+            d = dist(x, y)
+            if len(heap) < k:
+                heapq.heappush(heap, (-d, x, y))
+            else:
+                heapq.heappushpop(heap, (-d, x, y))
+
+        return [(x, y) for d, x, y in heap]
diff --git a/Koko Eating Bananas - Leetcode 875.py b/Koko Eating Bananas - Leetcode 875.py
@@ -0,0 +1,22 @@
+class Solution:
+    def minEatingSpeed(self, piles: List[int], h: int) -> int:
+        def k_works(k):
+            hours = 0
+
+            for p in piles:
+                hours += ceil(p / k)
+
+            return hours <= h
+
+        l = 1
+        r = max(piles)
+
+        while l < r:
+            k = (l + r) // 2
+
+            if k_works(k):
+                r = k
+            else:
+                l = k + 1
+
+        return r
diff --git a/Linked List Cycle - Leetcode 141.py b/Linked List Cycle - Leetcode 141.py
@@ -0,0 +1,14 @@
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        dummy = ListNode()
+        dummy.next = head
+        slow = fast = dummy
+
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+
+            if slow is fast:
+                return True
+
+        return False
diff --git a/Longest Repeating Character Replacement - Leetcode 424.py b/Longest Repeating Character Replacement - Leetcode 424.py
@@ -0,0 +1,16 @@
+class Solution:
+    def characterReplacement(self, s: str, k: int) -> int:
+        longest = 0
+        l = 0
+        counts = [0] * 26
+
+        for r in range(len(s)):
+            counts[ord(s[r]) - 65] += 1
+
+            while (r - l + 1) - max(counts) > k:
+                counts[ord(s[l]) - 65] -= 1
+                l += 1
+
+            longest = max(longest, (r - l + 1))
+
+        return longest
diff --git a/Longest Substring Without Repeating Characters - Leetcode 3.py b/Longest Substring Without Repeating Characters - Leetcode 3.py
@@ -0,0 +1,17 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        l = 0
+        longest = 0
+        sett = set()
+        n = len(s)
+
+        for r in range(n):
+            while s[r] in sett:
+                sett.remove(s[l])
+                l += 1
+
+            w = (r - l) + 1
+            longest = max(longest, w)
+            sett.add(s[r])
+
+        return longest
diff --git a/Lowest Common Ancestor of a Binary Tree - Leetcode 235.py b/Lowest Common Ancestor of a Binary Tree - Leetcode 235.py
@@ -0,0 +1,20 @@
+class Solution:
+    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        lca = [root]
+
+        def search(root):
+            if not root:
+                return
+
+            lca[0] = root
+            if root is p or root is q:
+                return
+            elif root.val < p.val and root.val < q.val:
+                search(root.right)
+            elif root.val > p.val and root.val > q.val:
+                search(root.left)
+            else:
+                return
+
+        search(root)
+        return lca[0]
diff --git a/Max Consecutive Ones III - Leetcode 1004.py b/Max Consecutive Ones III - Leetcode 1004.py
@@ -0,0 +1,19 @@
+class Solution:
+    def longestOnes(self, nums: List[int], k: int) -> int:
+        max_w = 0
+        num_zeros = 0
+        n = len(nums)
+        l = 0
+
+        for r in range(n):
+            if nums[r] == 0:
+                num_zeros += 1
+
+            while num_zeros > k:
+                if nums[l] == 0:
+                    num_zeros -= 1
+                l += 1
+            w = r - l + 1
+            max_w = max(max_w, w)
+
+        return max_w
diff --git a/Maximum Average Subarray I - Leetcode 643.py b/Maximum Average Subarray I - Leetcode 643.py
@@ -0,0 +1,18 @@
+class Solution:
+    def findMaxAverage(self, nums: List[int], k: int) -> float:
+        n = len(nums)
+        cur_sum = 0
+
+        for i in range(k):
+            cur_sum += nums[i]
+
+        max_avg = cur_sum / k
+
+        for i in range(k, n):
+            cur_sum += nums[i]
+            cur_sum -= nums[i - k]
+
+            avg = cur_sum / k
+            max_avg = max(max_avg, avg)
+
+        return max_avg
diff --git a/Maximum Depth of Binary Tree - Leetcode 104.py b/Maximum Depth of Binary Tree - Leetcode 104.py
@@ -0,0 +1,9 @@
+class Solution:
+    def maxDepth(self, root: Optional[TreeNode]) -> int:
+        if not root:
+            return 0
+
+        left = self.maxDepth(root.left)
+        right = self.maxDepth(root.right)
+
+        return 1 + max(left, right)
diff --git a/Merge Two Sorted Lists - Leetcode 21.py b/Merge Two Sorted Lists - Leetcode 21.py
@@ -0,0 +1,18 @@
+class Solution:
+    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
+        d = ListNode()
+        cur = d
+
+        while list1 and list2:
+            if list1.val < list2.val:
+                cur.next = list1
+                cur = list1
+                list1 = list1.next
+            else:
+                cur.next = list2
+                cur = list2
+                list2 = list2.next
+
+        cur.next = list1 if list1 else list2
+
+        return d.next
diff --git a/Middle of the Linked List - Leetcode 876.py b/Middle of the Linked List - Leetcode 876.py
@@ -0,0 +1,10 @@
+class Solution:
+    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        slow = head
+        fast = head
+
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+
+        return slow
diff --git a/Permutation in String - Leetcode 567.py b/Permutation in String - Leetcode 567.py
@@ -0,0 +1,25 @@
+class Solution:
+    def checkInclusion(self, s1: str, s2: str) -> bool:
+        n1 = len(s1)
+        n2 = len(s2)
+
+        if n1 > n2:
+            return False
+
+        s1_counts = [0] * 26
+        s2_counts = [0] * 26
+
+        for i in range(n1):
+            s1_counts[ord(s1[i]) - 97] += 1
+            s2_counts[ord(s2[i]) - 97] += 1
+
+        if s1_counts == s2_counts:
+            return True
+
+        for i in range(n1, n2):
+            s2_counts[ord(s2[i]) - 97] += 1
+            s2_counts[ord(s2[i - n1]) - ord("a")] -= 1
+            if s1_counts == s2_counts:
+                return True
+
+        return False
diff --git a/Remove Duplicates from Sorted List - Leetcode 83.py b/Remove Duplicates from Sorted List - Leetcode 83.py
@@ -0,0 +1,9 @@
+class Solution:
+    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        cur = head
+        while cur and cur.next:
+            if cur.val == cur.next.val:
+                cur.next = cur.next.next
+            else:
+                cur = cur.next
+        return head
diff --git a/Remove Nth Node from End of List - Leetcode 19.py b/Remove Nth Node from End of List - Leetcode 19.py
diff --git a/Reverse Linked List - Leetcode 206.py b/Reverse Linked List - Leetcode 206.py
diff --git a/Same Binary Tree - Leetcode 100.py b/Same Binary Tree - Leetcode 100.py
diff --git a/Search a 2D Matrix - Leetcode 74.py b/Search a 2D Matrix - Leetcode 74.py
diff --git a/Search in Rotated Sorted Array - Leetcode 33.py b/Search in Rotated Sorted Array - Leetcode 33.py
diff --git a/Subtree of Another Tree - Leetcode 572.py b/Subtree of Another Tree - Leetcode 572.py
diff --git a/Validate Binary Search Tree - Leetcode 98.py b/Validate Binary Search Tree - Leetcode 98.py
