hard questions

backend/data/questions/median-of-two-sorted-arrays.yaml

@@ -0,0 +1,122 @@
+title: Median of Two Sorted Arrays
+slug: median-of-two-sorted-arrays
+difficulty: hard
+leetcode_id: 4
+leetcode_url: https://leetcode.com/problems/median-of-two-sorted-arrays/
+categories:
+  - arrays
+  - binary-search
+patterns:
+  - binary-search
+
+description: |
+  Given two sorted arrays `nums1` and `nums2` of size m and n respectively, return the median
+  of the two sorted arrays.
+
+  The overall run time complexity should be O(log(m+n)).
+
+constraints: |
+  - nums1.length == m
+  - nums2.length == n
+  - 0 <= m <= 1000
+  - 0 <= n <= 1000
+  - 1 <= m + n <= 2000
+  - -10^6 <= nums1[i], nums2[i] <= 10^6
+
+examples:
+  - input: "nums1 = [1,3], nums2 = [2]"
+    output: "2.0"
+    explanation: "Merged array is [1,2,3]. Median is 2."
+  - input: "nums1 = [1,2], nums2 = [3,4]"
+    output: "2.5"
+    explanation: "Merged array is [1,2,3,4]. Median is (2+3)/2 = 2.5."
+
+explanation:
+  approach: |
+    1. Binary search on the smaller array for partition point
+    2. Partition both arrays such that left half has (m+n+1)//2 elements
+    3. Check if partition is valid: max(left) <= min(right)
+    4. If valid, compute median from boundary elements
+    5. Adjust binary search bounds based on comparison
+
+  intuition: |
+    The median divides the combined array into two halves of equal size. We don't need to
+    actually merge; we just need to find the correct partition.
+
+    If we choose i elements from nums1 for the left half, we need (m+n+1)//2 - i from nums2.
+    Binary search on i (0 to m) to find where nums1[i-1] <= nums2[j] and nums2[j-1] <= nums1[i].
+
+    This is O(log min(m,n)) since we binary search on the smaller array.
+
+  common_pitfalls:
+    - title: Not handling edge cases at partition
+      description: |
+        When partition is at array boundary (i=0 or i=m), use -inf or inf for boundary values.
+      wrong_approach: "Accessing nums1[i-1] when i=0"
+      correct_approach: "Use float('-inf') if i == 0"
+
+    - title: Binary searching on the longer array
+      description: |
+        Always binary search on the shorter array to ensure valid partition exists
+        and for better efficiency.
+
+    - title: Odd vs even total length
+      description: |
+        For odd total, median is max of left half.
+        For even, it's average of max(left) and min(right).
+
+  key_takeaways:
+    - Binary search on partition, not on values
+    - Partition both arrays to have equal halves
+    - Handle boundary conditions with infinity
+    - O(log min(m,n)) is achievable
+
+  time_complexity: "O(log min(m,n))"
+  space_complexity: "O(1)"
+  complexity_explanation: |
+    Time: Binary search on the smaller array.
+    Space: Only constant extra variables.
+
+solutions:
+  - approach_name: Binary Search on Partition (Optimal)
+    is_optimal: true
+    code: |
+      def find_median_sorted_arrays(nums1: list[int], nums2: list[int]) -> float:
+          # Ensure nums1 is the smaller array
+          if len(nums1) > len(nums2):
+              nums1, nums2 = nums2, nums1
+
+          m, n = len(nums1), len(nums2)
+          left, right = 0, m
+          half_len = (m + n + 1) // 2
+
+          while left <= right:
+              i = (left + right) // 2  # Partition in nums1
+              j = half_len - i          # Partition in nums2
+
+              # Handle edge cases with infinity
+              nums1_left = float('-inf') if i == 0 else nums1[i - 1]
+              nums1_right = float('inf') if i == m else nums1[i]
+              nums2_left = float('-inf') if j == 0 else nums2[j - 1]
+              nums2_right = float('inf') if j == n else nums2[j]
+
+              if nums1_left <= nums2_right and nums2_left <= nums1_right:
+                  # Found valid partition
+                  if (m + n) % 2 == 1:
+                      return max(nums1_left, nums2_left)
+                  else:
+                      return (max(nums1_left, nums2_left) +
+                              min(nums1_right, nums2_right)) / 2
+
+              elif nums1_left > nums2_right:
+                  # Too many elements from nums1 in left half
+                  right = i - 1
+              else:
+                  # Too few elements from nums1 in left half
+                  left = i + 1
+
+          return 0.0  # Should never reach here
+    explanation: |
+      Binary search to find correct partition point in the smaller array.
+      Partition is valid when all left elements <= all right elements.
+      Compute median from the four boundary elements.