medium array/string questions

2025-04-28 22:51:54 +01:00
parent c4856d9948
commit f8350bfdaf
3 changed files with 332 additions and 0 deletions
--- a/backend/data/questions/container-with-most-water.yaml
+++ b/backend/data/questions/container-with-most-water.yaml
@@ -0,0 +1,99 @@
+title: Container With Most Water
+slug: container-with-most-water
+difficulty: medium
+leetcode_id: 11
+leetcode_url: https://leetcode.com/problems/container-with-most-water/
+categories:
+  - arrays
+  - two-pointers
+patterns:
+  - two-pointers
+  - greedy
+
+description: |
+  You are given an integer array `height` of length n. There are n vertical lines drawn such
+  that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+
+  Find two lines that together with the x-axis form a container, such that the container
+  contains the most water.
+
+  Return the maximum amount of water a container can store.
+
+constraints: |
+  - n == height.length
+  - 2 <= n <= 10^5
+  - 0 <= height[i] <= 10^4
+
+examples:
+  - input: "height = [1,8,6,2,5,4,8,3,7]"
+    output: "49"
+    explanation: "Lines at index 1 (height 8) and 8 (height 7) form container with area 7 * 7 = 49."
+  - input: "height = [1,1]"
+    output: "1"
+    explanation: "Only container possible has area 1 * 1 = 1."
+
+explanation:
+  approach: |
+    1. Start with two pointers at the far left and far right
+    2. Calculate the area formed by the two lines
+    3. Move the pointer pointing to the shorter line inward
+    4. Track maximum area seen
+    5. Continue until pointers meet
+
+  intuition: |
+    Area = width × height. The height is limited by the shorter line.
+
+    Starting with maximum width (endpoints), we can only improve by finding taller lines.
+    If we move the taller pointer, width decreases and height can't increase beyond the
+    shorter line — so area can only decrease or stay the same.
+
+    Moving the shorter pointer gives us a chance to find a taller line that could
+    increase the height enough to compensate for the reduced width.
+
+  common_pitfalls:
+    - title: Moving the wrong pointer
+      description: |
+        Always move the pointer pointing to the shorter line. Moving the taller one
+        cannot possibly increase the area since height is constrained by the shorter.
+      wrong_approach: "Moving left pointer always or randomly"
+      correct_approach: "Move the pointer with smaller height[i]"
+
+    - title: Using nested loops
+      description: |
+        O(n²) brute force is unnecessary. Two pointers achieve O(n) by eliminating
+        suboptimal pairs without checking them.
+
+  key_takeaways:
+    - Two pointers from opposite ends is powerful for optimization
+    - Moving the limiting factor gives the best chance of improvement
+    - Greedy choice (move shorter) is provably optimal here
+    - Width × min(heights) is the key formula
+
+  time_complexity: "O(n)"
+  space_complexity: "O(1)"
+  complexity_explanation: |
+    Time: Each pointer moves at most n times total.
+    Space: Only a few variables for pointers and max area.
+
+solutions:
+  - approach_name: Two Pointers (Optimal)
+    is_optimal: true
+    code: |
+      def max_area(height: list[int]) -> int:
+          left, right = 0, len(height) - 1
+          max_water = 0
+
+          while left < right:
+              width = right - left
+              h = min(height[left], height[right])
+              max_water = max(max_water, width * h)
+
+              if height[left] < height[right]:
+                  left += 1
+              else:
+                  right -= 1
+
+          return max_water
+    explanation: |
+      Start from both ends and move the shorter line inward.
+      Track maximum area found during traversal.