```class Solution:
def maxArea(self, height: List[int]) -> int:
left, right = 0, len(height) - 1

maxArea = 0

while left < right:
heightOne = height[left]
heightTwo = height[right]

area = min(heightOne, heightTwo) * (right - left)
maxArea = max(area, maxArea)

if heightTwo >= heightOne: #if heights are equal, it doesn't matter if you move left or right pointer
left += 1
elif heightTwo < heightOne:
right -= 1

return maxArea

# BRUTE FORCE
#         maxArea = 0

#         for i in range(len(height)):
#             for secondI in range(i + 1, len(height)):
#                 heightOne = height[i]
#                 heightTwo = height[secondI]
#                 area = min(heightOne, heightTwo) * (secondI - i)
#                 maxArea = max(area, maxArea)

#         return maxArea ```
```# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
left = dummy
right = head #we actually want right to be head + n

#setting right to be head + n
while n > 0 and right:
right = right.next
n -= 1

#this should get left at previous and right at after thanks to dummy node we inserted
while right:
left = left.next
right = right.next

#delete node
left.next = left.next.next

return dummy.next

#bottom solution is what I first came up with and works in leetcode except for if head = [1] and n = 1 which is the case I tried to account for in the second elif statement but it gave me an error saying cannot return [] even though it was fine for the first if statement

#big O: is still O(n) just like 1st scenario

class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
return []
elif head.next is None and n == 1:
return []
else:
counter = 0 #will become length of LL

#to determine length of LL
while current is not None:
counter += 1
current = current.next

#consider adding an edge case here if n > counter

#second pass now knowing length of LL
new_counter = 0
target = counter - n
while new_counter is not target + 1:
if new_counter == (target - 1):
previous = current
if new_counter == target:
after = current.next
previous.next = after
current.next = None
break

current = current.next

new_counter += 1

```
star

Thu Sep 22 2022 18:45:49 GMT+0000 (Coordinated Universal Time) https://leetcode.com/problems/container-with-most-water/submissions/

#python #neetcode #pointer #two
star

Fri Aug 12 2022 20:01:25 GMT+0000 (Coordinated Universal Time) https://leetcode.com/problems/remove-nth-node-from-end-of-list/submissions/

#python #linked #list #two #pointer #dummy #node