# Leetcode Solving the “Container With Most Water” LeetCode Problem in JavaScript

The “Container With Most Water” problem is a classic algorithmic challenge that can be found on LeetCode. In this blog post, we’ll explore an efficient solution to this problem using JavaScript.

Problem Statement:

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*.

**Notice** that you may not slant the container.

**Example 1:**

**Input:** height = [1,8,6,2,5,4,8,3,7]
**Output:** 49
**Explanation:** The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.

**Example 2:**

**Input:** height = [1,1]
**Output:** 1

**Constraints:**

`n == height.length`

`2 <= n <= 105`

`0 <= height[i] <= 104`

### 1. Understanding the Problem:

The problem statement requires us to find the two lines on a 2D plane that form a container with the most water. The input is an array of non-negative integers, where each integer represents the height of a vertical line at a particular index. Our task is to determine the maximum amount of water that can be trapped by the container formed by any two lines from the array.

### 2. Approach:

To solve this problem efficiently, we can **use the two-pointer technique**. We’ll start with two pointers, one at the beginning of the array and the other at the end. We’ll calculate the area between the lines represented by these two pointers and keep track of the maximum area found so far. Then, we’ll move the pointer with the smaller height inward, as moving the pointer with the larger height wouldn’t yield a larger area.

3. JavaScript Solution:

` `

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

#### 4. Time and Space Complexity:

The two-pointer approach reduces the time complexity to O(n), where n is the number of elements in the height array, as we iterate through the array only once. The space complexity is O(1) since we use a constant amount of extra space.

#### Conclusion:

In this blog post, we discussed the “Container With Most Water” problem from LeetCode and provided an efficient JavaScript solution using the two-pointer technique. By incorporating proper SEO techniques, we aim to make this blog post more discoverable and helpful for developers seeking a solution to this classic algorithmic problem. Happy coding!