## Problem Overview

Given `n` non-negative integers `a1, a2, ..., an` , where each represents a point at coordinate `(i, ai)`. `n` vertical lines are drawn such that the two endpoints of the line `i` is at `(i, ai)` and `(i, 0)`. Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.

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

## Solutions

### Time Complexity: O(n^2)

### Space Complexity: O(1)

Compare each point with each other, keeping track of the maximum container (biggest area)

```python
def maxArea(self, height: List[int]) -> int:
        
        def calculateArea(pointA, pointB):
         # Width would be determine by the difference between array indices
            width = pointB[0] - pointA[0]

         # The smaller height takes precedence of the container's height

            height = min(pointA[1], pointB[1])
            return width * height

        maxArea = 0
        for k in range(0, len(height)):
            x_1 = k + 1
            y_1 = height[k]
            
            for j in range(0, len(height)):
                x_2 = j+1
                y_2 = height[j]
                area = calculateArea([x_1,y_1],[x_2,y_2])
                maxArea = max(area, maxArea)
                
        return maxArea
```

### Time Complexity: O(n)

### Space Complexity: O(1)

For optimization of my previous solution, instead of comparing each point with all the other ones to determine the highest area, we would assign 2 pointers on the leftmost and the rightmost side of the array, because at that point we would have the highest width the container could be, but not necessarily the highest width. So to ensure that we would get the maximum area possible, it's noted that the height of the container is naturally the height of the smaller point (in terms of where it lies on the y-axis), so taking a greedy approach, we would shift the pointer to move from the side with the shorter height onto to the next point and keep checking the areas until the pointers point to the same index.

```python
def maxArea(self, height: List[int]) -> int:
        
        def calculateArea(pointA, pointB):
         # Width would be determine by the difference between array indices
            width = pointB[0] - pointA[0]

         # The smaller height takes precedence of the container's height

            height = min(pointA[1], pointB[1])
            return width * height
        
        l, r = 0, len(height) - 1 
        maxArea = calculateArea( [l + 1, height[l]], [r + 1, height[r]])
        
        while (l != r):
            
            area = calculateArea( [l + 1, height[l]], [r + 1, height[r]])
            maxArea = max(maxArea, area)   
            
            # Shrinks the container's width on the side with the shorter height
            
            if (height[l] < height[r]):
                l += 1
            else:
                r -= 1
            
        return maxArea
```

Given `n` non-negative integers `a1, a2, ..., an` , where each represents a point at coordinate `(i, ai)`. `n` vertical lines are drawn such that the two endpoints of the line `i` is at `(i, ai)` and `(i, 0)`. Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.


🌊 Container With Most Water

## Problem Overview

Given a string `s`, find the length of the **longest substring**
 without repeating characters.

## Solutions

### Time Complexity: O(n^2)

### Space Complexity: O(1)

Iterate through each character and create nested loops that will generate each possible substring and keep track of the substrings with non-duplicating characters

```python
def lengthOfLongestSubstring(s):
    if len(s) == 0:
        return 0
    elif len(s) == 1:
        return 1
    else:
        max_len = 0
        for i in range(len(s)):
            for j in range(i+1, len(s)+1):
                if len(set(s[i:j])) == len(s[i:j]):
                    max_len = max(max_len, len(s[i:j]))
        return max_len
```

### Time Complexity: O(n)

### Space Complexity: O(1)

Using a set or hash set data structure, I would loop and add each char to the set, on each iteration I would check for a duplicate entry (checking for duplicates in a set is constant time / O(1) ), if a duplicate is spotted I would pop the set to the left until there are no duplicates, and continue iterating and adding more characters from the string to the set (repeating the dup checking process) while keeping track of the longest non duplicate sub string so far

```python
def lengthOfLongestSubstring(s):
    char_set = {}
    l = 0
    max_length = 0
    for r in range(len(s)):
        if s[r] in char_set:
            l = max(l, char_set[s[r]] + 1)
        char_set[s[r]] = r
        max_length = max(max_length, r-l+1)
    return max_length
```

Longest Substring Without Repeating Characters