init thoughts:

as im going to start keeping these notes (or transposing them? ) on a blog, i thought it would be helpful to keep my initial thoughts for others and for myself. SO - containter with most water. biolded down, i seems like a pretty easy question - out of this given list, what range do most of the numbers fall under. and then what are those two numbers multiplied? ex | given: [] 1,7,2,5,4,7,3,6] ans : most numbers are between 7 and 6 ans : return 7 * 6

wahhhh wait i might have misunderstood the question... yeah i diddddd

Each number in the array is a vertical bar. You're picking two bars to act as the walls of a container, and checking how much water it can hold.

Water amount = width × height, where:

• width = distance between the two bars (index difference)
• height = the shorter of the two bars (water spills over the shorter wall)

i was only thinking of widthhh damn geometery.

hmm okay, so. pointers then. start on left and right, multiply the numbers together and record the heighest is the brute force method....

could use my misconseption eariler - check the pairs with the best range between them then compare form the smaller list.

so [ 1,7,2,5,4,7,3,6] -> [1,6] [7,7] [7,6]

then multply those... but i'd need to keep track of the indeces two...

could keep track of the largest l and right #, each time a max l or r is found, them multply. if that sum is greater then the current - save it. if not, let it go.

this would iterate over the array only once, but create at least 3 new memory address (max_sum, max_l, max_r) as l and r would be handled by the for loop.

not my cleanest idea imo,,, but i could try it?

use left and right, max = sum : [ l , r]

bro i literally had a dream about this one and i still don't understand :((((

watching a vid, i'll put my notes here ----

my thought was to go through the string, if the element is an open para ( ex - [ ) ']' then add to my stack automatically, if it's closed but stack is empty, then return false. if it doesn't match, return false.

i used a stack because of First In - First Out logic and a dict to check values and keys to reduce using up memory on two separate sets or a bunch of manual checking which would have impacted code legibility.

- legible ( if redundant) and the var names could be better

- not the biggest fan of how long or complex some of the checks are

- i did fully forget to account for an edge case (starting with the closing para) so whoop hehe

- not pythonic! Theres a lot here that i could streamline by using general python syntax. i'm going to blame my java-first brain and accept that haha

- also, dict checks the keys by default - `set_checker.keys() ` is hand holding

- learning!!

- initiation was good with this one. glad that i got to use a dict lol

            from collections import deque
            class Solution:
            
              def isValid(self, s: str) -> bool:
              
              stack = deque()
              
              temp = ""
              
              set_checker = {"(":")","{":"}", "[":"]"}
              
              for element in s:
              
                if element in set_checker.keys():
                
                  stack.append(element)
                
                elif element in set_checker.values() and len(stack) != 0:
                
                  temp = stack.pop()
                  
                if element != set_checker[temp]:
                
                  return False
                
                else:
                
                  return False
              
              return False if len(stack) != 0 else True
            

            class Solution:
            def isValid(self, s: str) -> bool:
                stack = []
                matcher = {"(": ")", "{": "}", "[": "]"}
        
                for char in s:
                    if char in matcher:
                        stack.append(char)
                    elif not stack or matcher[stack.pop()] != char:
                        return False
        
                return not stack
            

. `deque` → regular `list`** A plain list is all you need for a stack. `deque` is useful when you need to pop/append from **both ends** — here you only use one end, so `list` is simpler and more readable. **2. Removed `temp`** The temporary variable was unnecessary — you can pop and compare in one line: