chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-10-04-11-Container-With-Most-Water/explanation.md

@@ -0,0 +1,40 @@
+# Container With Most Water (Medium)
+
+**Problem ID:** 11  
+**Date:** 2025-10-04  
+**Link:** https://leetcode.com/problems/container-with-most-water/
+
+## Approach
+
+To solve the "Container With Most Water" problem, we can utilize a two-pointer approach, which is efficient and optimal for this scenario.
+
+### Problem Understanding:
+The goal is to find two vertical lines from the given array that, together with the x-axis, form a container that can hold the maximum amount of water. The water held by the container is determined by the shorter of the two lines and the distance between them.
+
+### Approach:
+1. **Two-Pointer Technique**: 
+   - Initialize two pointers: `left` at the beginning (index 0) and `right` at the end (index n-1) of the array.
+   - Calculate the area formed by the lines at these two pointers. The area can be computed using the formula:
+     \[
+     \text{Area} = \text{min}(height[left], height[right]) \times (right - left)
+     \]
+   - Keep track of the maximum area encountered.
+
+2. **Pointer Adjustment**:
+   - To potentially find a larger area, we need to adjust the pointers:
+     - If the height at the `left` pointer is less than the height at the `right` pointer, increment the `left` pointer (move it to the right).
+     - Otherwise, decrement the `right` pointer (move it to the left).
+   - This adjustment is based on the fact that moving the pointer pointing to the shorter line might lead to a taller line, which could increase the area.
+
+3. **Iteration**:
+   - Continue this process until the two pointers meet. During each iteration, update the maximum area if the current area is greater than the previously recorded maximum.
+
+### Data Structures:
+- The primary data structure used is the integer array `height`, which stores the heights of the vertical lines.
+- Two integer variables are used for the pointers (`left` and `right`) and one for tracking the maximum area.
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the `height` array. Each element is processed at most twice (once by each pointer).
+- **Space Complexity**: O(1), as we are using a constant amount of extra space regardless of the input size.
+
+This two-pointer approach efficiently narrows down the potential maximum area without needing to check every possible pair of lines, making it suitable for the constraints provided in the problem.

Medium/2025-10-04-11-Container-With-Most-Water/solution.java

@@ -0,0 +1,20 @@
+class Solution {
+    public int maxArea(int[] height) {
+        int left = 0, right = height.length - 1;
+        int maxArea = 0;
+
+        while (left < right) {
+            int width = right - left;
+            int currentHeight = Math.min(height[left], height[right]);
+            maxArea = Math.max(maxArea, width * currentHeight);
+
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return maxArea;
+    }
+}

Medium/2025-10-04-11-Container-With-Most-Water/solution.js

@@ -0,0 +1,20 @@
+var maxArea = function(height) {
+    let left = 0;
+    let right = height.length - 1;
+    let maxArea = 0;
+
+    while (left < right) {
+        const width = right - left;
+        const currentHeight = Math.min(height[left], height[right]);
+        const area = width * currentHeight;
+        maxArea = Math.max(maxArea, area);
+
+        if (height[left] < height[right]) {
+            left++;
+        } else {
+            right--;
+        }
+    }
+
+    return maxArea;
+};

Medium/2025-10-04-11-Container-With-Most-Water/solution.py

@@ -0,0 +1,16 @@
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        left, right = 0, len(height) - 1
+        max_area = 0
+        
+        while left < right:
+            width = right - left
+            current_height = min(height[left], height[right])
+            max_area = max(max_area, width * current_height)
+            
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+        
+        return max_area

README.md

@@ -166,3 +166,4 @@ Each problem includes:
 - 2025-10-01 — [Water Bottles](https://leetcode.com/problems/water-bottles/) (Easy) → `Easy/2025-10-01-1518-Water-Bottles`
 - 2025-10-02 — [Water Bottles II](https://leetcode.com/problems/water-bottles-ii/) (Medium) → `Medium/2025-10-02-3100-Water-Bottles-II`
 - 2025-10-03 — [Trapping Rain Water II](https://leetcode.com/problems/trapping-rain-water-ii/) (Hard) → `Hard/2025-10-03-407-Trapping-Rain-Water-II`
+- 2025-10-04 — [Container With Most Water](https://leetcode.com/problems/container-with-most-water/) (Medium) → `Medium/2025-10-04-11-Container-With-Most-Water`