fornmatter

Author: romankurnovskii

.husky/pre-commit

@@ -1 +1,2 @@
 npm run format:json
+npm run format:python

explanations/57/en.md

@@ -1,97 +1,61 @@
-You are given an array of non-overlapping intervals `intervals` where `intervals[i] = [start_i, end_i]` represent the start and the end of the `i^th` interval and `intervals` is sorted in ascending order by `start_i`. You are also given an interval `newInterval = [start, end]` that represents the start and end of another interval.
-
-Insert `newInterval` into `intervals` such that `intervals` is still sorted in ascending order by `start_i` and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).
-
-Return `intervals` *after the insertion*.
-
-**Note** that you don't need to modify `intervals` in-place. You can make a new array and return it.
-
-**Example 1:**
-
-```sh
-Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
-Output: [[1,5],[6,9]]
-```
-
-**Example 2:**
-
-```sh
-Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
-Output: [[1,2],[3,10],[12,16]]
-Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
-```
-
-**Constraints:**
+## Explanation
 
-- `0 <= intervals.length <= 10^4`
-- `intervals[i].length == 2`
-- `0 <= start_i <= end_i <= 10^5`
-- `intervals` is sorted by `start_i` in **ascending** order.
-- `newInterval.length == 2`
-- `0 <= start <= end <= 10^5`
+### Strategy (The "Why")
 
-## Explanation
+**Restate the problem:** We are given a sorted array of non-overlapping intervals and a new interval. We need to insert the new interval into the array such that the result remains sorted and all overlapping intervals are merged.
 
-### Strategy
+**1.1 Constraints & Complexity:**
 
-This is an **array manipulation problem** that requires inserting a new interval into a sorted list of non-overlapping intervals. The key insight is to process intervals in three phases: before overlap, during overlap, and after overlap.
+- **Input Size:** Up to 10^4 intervals, each with start and end values up to 10^5.
+- **Time Complexity:** O(n) where n is the number of intervals. We traverse the array once, processing each interval at most once.
+- **Space Complexity:** O(n) to store the result array.
+- **Edge Case:** If the intervals array is empty, we return an array containing only the new interval.
 
-**Key observations:**
-- Intervals are already sorted by start time
-- We need to find where the new interval fits
-- We may need to merge multiple overlapping intervals
-- Process intervals in three phases based on overlap with new interval
+**1.2 High-level approach:**
 
-**High-level approach:**
-1. **Add intervals before overlap**: Add all intervals that end before new interval starts
-2. **Merge overlapping intervals**: Find all intervals that overlap with new interval
-3. **Add merged interval**: Add the final merged interval
-4. **Add remaining intervals**: Add all intervals that start after new interval ends
+The goal is to process intervals in three phases: add intervals that come before the new interval, merge all intervals that overlap with the new interval, and add the remaining intervals that come after.
 
-### Steps
+**1.3 Brute force vs. optimized strategy:**
 
-Let's break down the solution step by step:
+- **Brute Force:** Insert the new interval, sort the entire array, then merge overlapping intervals. This would be O(n log n) time due to sorting.
+- **Optimized Strategy:** Since intervals are already sorted, we can process them in a single pass: add intervals before overlap, merge overlapping ones, then add remaining intervals. This is O(n) time.
+- **Optimization:** By leveraging the fact that intervals are already sorted, we avoid the need for sorting and can process everything in one pass, making the solution more efficient.
 
-**Step 1: Initialize result list**
-- Create empty result list: `result = []`
+**1.4 Decomposition:**
 
-**Step 2: Add intervals before overlap**
-- Add all intervals where `interval[1] < newInterval[0]`
+1. Add all intervals that end before the new interval starts (no overlap).
+2. Merge all intervals that overlap with the new interval by updating the start and end boundaries.
+3. Add the merged interval to the result.
+4. Add all remaining intervals that start after the merged interval ends.
 
-**Step 3: Merge overlapping intervals**
-- Find all intervals that overlap with new interval
-- Update new interval boundaries: `start = min(start, interval[0])`, `end = max(end, interval[1])`
+### Steps (The "How")
 
-**Step 4: Add merged interval**
-- Add the final merged interval to result
+**2.1 Initialization & Example Setup:**
 
-**Step 5: Add remaining intervals**
-- Add all intervals where `interval[0] > newInterval[1]`
+Let's use the example: `intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]]`, `newInterval = [4,8]`
 
-**Example walkthrough:**
-Let's trace through the second example:
+- Result array: `res = []`
+- Index `i = 0`
+- New interval boundaries: `start = 4`, `end = 8`
 
-```sh
-intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+**2.2 Start Processing:**
 
-Step 1: Add intervals before overlap
-result = [[1,2]] (3,5 overlaps, so stop)
+We begin processing intervals from left to right, checking each interval's relationship with the new interval.
 
-Step 2: Merge overlapping intervals
-Overlap with [3,5]: newInterval = [min(4,3), max(8,5)] = [3,8]
-Overlap with [6,7]: newInterval = [min(3,6), max(8,7)] = [3,8]
-Overlap with [8,10]: newInterval = [min(3,8), max(8,10)] = [3,10]
+**2.3 Trace Walkthrough:**
 
-Step 3: Add merged interval
-result = [[1,2],[3,10]]
+| Step | i | Interval | Condition | Action | res | start, end |
+| ---- | - | -------- | --------- | ------ | --- | ---------- |
+| 1    | 0 | [1,2] | 2 < 4 (ends before) | Add to res | `[[1,2]]` | 4, 8 |
+| 2    | 1 | [3,5] | 3 <= 8 (overlaps) | Merge: start=min(4,3)=3, end=max(8,5)=8 | `[[1,2]]` | 3, 8 |
+| 3    | 2 | [6,7] | 6 <= 8 (overlaps) | Merge: start=min(3,6)=3, end=max(8,7)=8 | `[[1,2]]` | 3, 8 |
+| 4    | 3 | [8,10] | 8 <= 8 (overlaps) | Merge: start=min(3,8)=3, end=max(8,10)=10 | `[[1,2]]` | 3, 10 |
+| 5    | 4 | [12,16] | 12 > 10 (starts after) | Add merged [3,10], then add [12,16] | `[[1,2],[3,10],[12,16]]` | - |
 
-Step 4: Add remaining intervals
-result = [[1,2],[3,10],[12,16]]
+**2.4 Increment and Loop:**
 
-Result: [[1,2],[3,10],[12,16]]
-```
+After processing each interval, we increment the index `i` and continue until all intervals are processed.
 
-> **Note:** The key insight is to process intervals in three phases. This approach is efficient because we only need to traverse the array once, and we can determine which phase each interval belongs to by comparing its boundaries with the new interval.
+**2.5 Return Result:**
 
-**Time Complexity:** O(n) - we visit each interval at most once  
-**Space Complexity:** O(n) - to store the result 
+The result is `[[1,2],[3,10],[12,16]]`, where the new interval [4,8] has been merged with overlapping intervals [3,5], [6,7], and [8,10] to form [3,10].

package.json

@@ -1,6 +1,7 @@
 {
   "scripts": {
     "format:json": "prettier --write 'data/**/*.json'",
+    "format:python": "black scripts/ solutions/",
     "prepare": "husky"
   },
   "devDependencies": {

requirements.txt

@@ -1,2 +1 @@
-
-
+black>=24.0.0

scripts/update_problems_from_leetcode.py

@@ -102,10 +102,7 @@ def map_tags_to_category(tags: List[Dict[str, str]]) -> str:
     elif any("greedy" in t for t in all_tags):
         return "Greedy"
     elif any(
-        "math" in t
-        or "geometry" in t
-        or "number-theory" in t
-        or "combinatorics" in t
+        "math" in t or "geometry" in t or "number-theory" in t or "combinatorics" in t
         for t in all_tags
     ):
         return "Math & Geometry"
@@ -324,4 +321,3 @@ def main():
 
 if __name__ == "__main__":
     main()
-

solutions/100/01.py

@@ -9,14 +9,13 @@ def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
         # Both are None
         if not p and not q:
             return True
-        
+
         # One is None, the other is not
         if not p or not q:
             return False
-        
+
         # Both exist, check values and recursively check children
         if p.val != q.val:
             return False
-        
-        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
 
+        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)

solutions/1004/01.py

@@ -1,23 +1,24 @@
 from typing import List
 
+
 class Solution:
     def longestOnes(self, nums: List[int], k: int) -> int:
         left = 0
         max_length = 0
         zero_count = 0
-        
+
         for right in range(len(nums)):
             # Expand window
             if nums[right] == 0:
                 zero_count += 1
-            
+
             # Shrink window if zero_count exceeds k
             while zero_count > k:
                 if nums[left] == 0:
                     zero_count -= 1
                 left += 1
-            
+
             # Update maximum length
             max_length = max(max_length, right - left + 1)
-        
+
         return max_length

solutions/1008/01.py

@@ -8,15 +8,15 @@ class Solution:
     def bstFromPreorder(self, preorder: List[int]) -> Optional[TreeNode]:
         if not preorder:
             return None
-        
+
         root = TreeNode(preorder[0])
-        
+
         # Find the split point where values become greater than root
         i = 1
         while i < len(preorder) and preorder[i] < preorder[0]:
             i += 1
-        
+
         root.left = self.bstFromPreorder(preorder[1:i])
         root.right = self.bstFromPreorder(preorder[i:])
-        
+
         return root

solutions/101/01.py

@@ -5,19 +5,21 @@
 #         self.left = left
 #         self.right = right
 
+
 class Solution:
     def isSymmetric(self, root) -> bool:
         def is_mirror(left, right):
             if not left and not right:
                 return True
             if not left or not right:
                 return False
-            return (left.val == right.val and 
-                    is_mirror(left.left, right.right) and 
-                    is_mirror(left.right, right.left))
-        
+            return (
+                left.val == right.val
+                and is_mirror(left.left, right.right)
+                and is_mirror(left.right, right.left)
+            )
+
         if not root:
             return True
-        
-        return is_mirror(root.left, root.right)
 
+        return is_mirror(root.left, root.right)

solutions/102/01.py

@@ -8,28 +8,28 @@
 from typing import List
 from collections import deque
 
+
 class Solution:
     def levelOrder(self, root) -> List[List[int]]:
         if not root:
             return []
-        
+
         res = []
         queue = deque([root])
-        
+
         while queue:
             level_size = len(queue)
             level = []
-            
+
             for _ in range(level_size):
                 node = queue.popleft()
                 level.append(node.val)
-                
+
                 if node.left:
                     queue.append(node.left)
                 if node.right:
                     queue.append(node.right)
-            
+
             res.append(level)
-        
-        return res
 
+        return res