Sol 1: N Size Window (Left Right Curr Buy Today Sell Prices)
1. (left, right = 0, 0)
1. (maxProfit = 0)
2. while right < n:
   a. currBuyPrice = prices[left] 
   b. todaySellPrice = prices[right]
   c. if currBuyPrice < todaySellPrice:
         maxProfit = max(maxProfit, (todaySellPrice - currBuyPrice))
   d. else:
         left = right
   e. right += 1
3. return maxProfit

Sol 3: Best Buy Sell Price Up To Today State Compression Variables
1. (currBuyPrice = -prices[0])
2. (maxProfit = 0)
2. For i in range(1, n):
   a. currBuyPrice = max(currBuyPrice, -prices[i])
   b. maxProfit = max(maxProfit, currBuyPrice + prices[i])
3. return maxProfit

    def maxProfit(self, prices: List[int]) -> int:

        # Sliding Window (Variable Size)

        # Stock Representation:
        #   - Window will grow from 0 to n as we iterate
        #   - Left and right represent: 
        #        left: best buy day so far (lowest price seen)
        #        right: current sell day candidate (highest prices seen)
        #   - Treat each day as a potential sell day

        # Idea:
        #   - Always buy before you sell
        #   - If current price is higher than buy price, compute profit
        #   - If current price is lower than buy price, we have found better buy price, reset window

        n = len(prices)

        # Sliding Window Representation:
        # There is no window representation,
        # the window simply grows to include the entire array
        # with our left and right tracking the best buy and sell prices within the window

        # Max profit seen so far given our best buy and best sell
        maxProfit = 0

        # Left: lowest price so far
        # Right: todays price
        left = 0
        right = 0

        # tc: O(n)
        while right < n:

            # Grab current best prices
            currBuyPrice = prices[left]
            todaySellPrice = prices[right]

            # Check: 
            # can we make a profit
            if currBuyPrice < todaySellPrice:
                
                # Calculate profit and compare
                profit = todaySellPrice - currBuyPrice
                maxProfit = max(maxProfit, profit)

            # Check: 
            # is this a better buy
            else:
                # update best buy day
                left = right

            # Iterate to next price
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return maxProfit

    def maxProfit(self, prices: List[int]) -> int:

        # Dynamic Programming (Full DP Table)

        # Window Representation:
        #   - Maintain window within [i]
        #   - currBuyPrice[i][0]: best buy day so far:
        #       we represent this by min(-currBuyPrice) for easier later calculations
        #
        #   - currBuyPrice[i][1]: best profit price up to day i    

        # Idea:
        #   - Always buy before you sell (<= index 1)
        #   - Check if new buy day found
        #   - Check if new best profit found


        # Empty check: no profit to be made
        if not prices:
            return 0

        n = len(prices)

        # Initialize DP:
        # sc: O(n)
        dp = []
        
        # Fill dp table:
        #   - dp[i][0]: best buy price up to day i
        #   - dp[i][1]: best profit price up to day i
        # tc: O(n)
        for i in range(n):
            dp.append([0, 0])

        
        # Initialize DP:
        # i = day
        # dp[i][0]: set best buy price to day 0
        # dp[i][1]: set best profit made up to day 0 
        #           (cannot buy and sell on same day, so profit on day 0 is 0)
        # tc: O(1)
        dp[0][0] = -prices[0]
        dp[0][1] = 0

        # start from second day
        # tc: iterate across n days O(n)
        for i in range(1, n):

            # Check: grab todays buy price
            # Use profit to explain our buy price:
            #     profit = hold + todaySellPrice
            #            = (-3) + 10
            #            = 7       
            todayPrice = -prices[i]

            # Check: grab best buy price up to yesterday
            bestBuyUpToYesterday = dp[i-1][0]

            # Check: grab new buy price
            dp[i][0] = max(bestBuyUpToYesterday, todayPrice)     

            # Check: todays profit
            todayProfit = bestBuyUpToYesterday + prices[i]
            
            # Check: grab new best profit, cannot sell today, so use yesterdays price    
            dp[i][1] = max(dp[i-1][1], todayProfit)


        # overall: tc O(n)
        # overall: sc O(n)
        return dp[-1][1]

    def maxProfit(self, prices: List[int]) -> int:

        # Dynamic Programming (State Compression)

        # Stock Representation:
        #   - Treat each day as potential sell day
        #   - Maintain a state tracking where:
        #        currBuyPrice: best buy price so far (lowest price seen)
        #        profit: most profit made so far (highest profit made using each day as a sell day)

        # Idea:
        #   - Always buy before you sell
        #   - If current price is higher than buy price, compute profit
        #   - If current price is lower than buy price, we have found better buy price, reset window

        n = len(prices)

        # set up compressed dynamic programming table first iteration:        
        # [i][0] -> min buying price up to day i
        # [i][1] -> max profit up to day i

        # Initialize Compressed DP:
        #   - min price up to day 0
        #   - max profit up to day 0
        currBuyPrice = -prices[0]
        maxProfit = 0

        # start from second day
        # tc: iterate over n days O(n)
        for i in range(1, n):
            
            # Put buy price as negative,
            # to ensure we always subtract it from out buy price
            #     profit = hold + todaySellPrice
            #            = (-3) + 10
            #            = 7       
            todayPrice = -prices[i]

            # Check: compare best buy price up to yesterday to today buy price
            currBuyPrice = max(currBuyPrice, todayPrice)

            todayProfit = currBuyPrice + prices[i]

            # profit = hold + todaySellPrice
            #        = (-3) + 10
            #        = 7
            maxProfit = max(maxProfit, todayProfit)  

        # overall: tc O(n)
        # overall: sc O(1)
        return maxProfit

Sol 1: MRI HashMap Checking Duplicates In K Window Based On Left Right Pointers
1. if n <= 1 or k <= 0: 
    a. return false
2. (mri = {})
3. For right in range(n):
    a. if nums[right] in mri:
         left = right - k
         prevIndex = mri[nums[right]]
         if left <= prevIndex <= right: 
             return true
   b. mri[nums[right]] = right
4. return false

Sol 2: Window HashSet K Tracking Nums Within Window
1. if n <= 1 or k <= 0: 
    return false
2. (window = {}) 
3. (left = 0)
3. while right < n:
    a. if nums[right] in window: 
         return true
    b. window.add(nums[right])
    c. if k < len(window):
         window.remove(nums[left])
         left += 1
    d. right += 1
4. return false

    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        
        # Sliding Window + HashMap (Fixed Size Window):

        # Window Representation:
        #   - HashMap for each number representing (val -> most recent index)

        # Idea:
        #   - Slide window over num list and add index at right boundary
        #   - Check mri if we have a duplicate of the current element,
        #     and if a duplicate exists within the k window [left, right]
    
        # Track more recent index appearance for num
        # sc: O(n)
        mri = {}

        # Sliding Window Variables
        n = len(nums)
        right = 0

        # Empty Case:
        # if not enough days to have a duplicate
        if n <= 1 or k <= 0:
            return False

        # tc: O(n)
        for right in range(n):

            currNum = nums[right]

            # Check: if num has already been seen
            # tc: O(1)
            if currNum in mri:

                #     k distance
                #  | ------------ |
                # left          right 

                # Index Distance No More Than k Apart (not element count):
                # the furthest left index that is still within k distance
                left = right - k

                # Check: 
                # if previous num copy is within current window, duplicate exists
                if left <= mri[currNum] <= right:
                    return True

            # Implies: no duplicate exists
            # Then: update mri for num
            mri[currNum] = right

        # No duplicates found within distance k

        # overall: tc O(n)
        # overall: sc O(min(n, k))
        return False

    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        
        # Sliding Window HashSet Right Left Representation (Fixed Size Window):

        # Window Representation:
        #   - Set() of width k spanning [left, right]
        #   - Numbers enter and exit window via left and right

        # Idea:
        #   - Slide fixed size window over list
        #   - Add element at right, remove element from left
        #   - Check if num we added is already within window boundary

        n = len(nums)

        # Empty Case:
        # Single list or window of length k cannot have duplicates
        if n <= 1 or k <= 0:
            return False

        # Sliding Window Data:
        # sc: O(k)
        window = set()

        # Sliding Window Boundaries:
        left = 0
        right = 0

        # Early exit: 
        # all elements are unique, no duplicates
        if len(set(nums)) == n:
            return False

        # tc: O(n)
        while right < n:

            # Check: 
            # if duplicate num exist in window
            if nums[right] in window:
                return True

            # Window Extend:
            # right index enters window:
            window.add(nums[right])
            right += 1

            # Window Shrink:
            # if we've fixed width of window,
            # left index exits window:
            if k < len(window):
                window.remove(nums[left])
                left += 1



        # No duplicates found within k window

        # overall: tc O(n)
        # overall: sc O(min(n, k))
        return False

  oh! pseudocode hasn't been written yet, try another card! :)

    def checkInclusion(s1: str, s2: str) -> bool:

        # Sliding Window (Fixed Size Window)

        # Substring Representation:
        #   - Maintain window [left, right]
        #   - Window size always equals len(s1)
        #   - Hashmap: char -> frequency

        # Idea:
        #   - Build a frequency map for s1
        #   - Expand right pointer to build window in s2
        #   - If window size exceeds len(s1), shrink from left
        #   - If window frequency == s1 frequency, permutation exists

        # Since window size is fixed, left moves whenever
        # window grows larger than lens1)

        n1 = len(s1)
        n2 = len(s2)

        # s2 < s1: permutation not possible
        # tc: O(1)
        if n2 < n1:
            return False

        # s1 Frequency
        # tc: O(n)
        # sc: O(n)
        needleCharCount = defaultdict(int)
        for c in s1:
            needleCharCount[c] += 1

        # Substring window frequency
        # sc: O(1)
        windowCharCount = defaultdict(int)
        
        # left and right boundary of current window
        left = 0
        right = 0

        # tc: O(n)
        for right in range(n2):

            # Add char count to window
            rightChar = s2[right]
            windowCharCount[rightChar] += 1

            # Window length
            currWindowLen = right - left + 1

            # Shrink from left while window is invalid:
            #   - window length is greater than needle length
            #   - since we extend window by 1 char, we only need to decrease by 1 char
            if n1 < currWindowLen:

                # Decrease char count from window
                leftChar = s2[left]
                windowCharCount[leftChar] -= 1

                # Remove char if frequency reached zero,
                # to match needle hashmap
                if windowCharCount[leftChar] == 0:
                    del windowCharCount[leftChar]
                
                # Shrink window
                left += 1
            
            # If window hashmap matches the needle hashmap,
            # valid permutation found
            if windowCharCount == needleCharCount:
                return True

        # overall: tc O(n) 
        # overall: sc O(n)
        return False

    def checkInclusion(self, s1: str, s2: str) -> bool:

        # Sliding Window (Fixed Size Window)

        # Substring Representation:
        #   - Maintain window [left, right]
        #   - Window size always equals len(s1)
        #   - Frequency array: char -> frequency (size 26 for lowercase letters)

        # Idea:
        #   - Build a frequency array for s1
        #   - Expand right pointer to build window in s2
        #   - If window size exceeds len(s1), shrink from left
        #   - If window frequency == s1 frequency, permutation exists

        # Since window size is fixed, left moves whenever
        # window grows larger than len(s1)

        n1 = len(s1)
        n2 = len(s2)

        # If needle length is greater than haystack length:
        if n2 < n1:
            return False

        # s1 Frequency
        # tc: O(n)
        # sc: O(1)
        needleCharCount = [0] * 26
        for c in s1:
            needleCharCount[ord(c) - 97] += 1

        # Substring window frequency
        # sc: O(1)
        windowCharCount = [0] * 26

        # left and right boundary of current window
        left = 0
        right = 0

        # tc: O(n)
        for right in range(n2):

            # Add char count to window
            rightChar = s2[right]
            windowCharCount[ord(rightChar) - 97] += 1

            # Window length
            currWindowLen = right - left + 1

            # Shrink from left while window is invalid:
            #   - window length is greater than needle length
            #   - since we extend window by 1 char, we only need to decrease by 1 char
            if n1 < currWindowLen:

                # Decrease char count from window
                leftChar = s2[left]
                windowCharCount[ord(leftChar) - 97] -= 1

                # No need to "remove" the 0 count chars
                # since all empty chars are already set to 0

                # Shrink window
                left += 1

            # If window frequency array matches the needle frequency array,
            # valid permutation found
            if windowCharCount == needleCharCount:
                return True

        # overall: tc O(n)
        # overall: sc O(1)
        return False

  oh! pseudocode hasn't been written yet, try another card! :)

    def findClosestElements(self, arr: list[int], k: int, x: int) -> list[int]:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - Window starts as the whole array and only shrinks
        #   - Window is done when it holds exactly k elements

        # Idea:
        #   - arr is sorted, so the k closest elements form a contiguous window
        #   - Compare the distance from x of the left num and the right num
        #   - The farther one can never be in the answer, since everything between it
        #     and x is closer, so drop it
        #   - On a tie, drop the right num, since the problem prefers the smaller value
        #   - Repeat until k elements remain

        # Index of last element
        lastIndex = len(arr) - 1

        # Sliding Window Boundaries
        left = 0
        right = lastIndex

        # Elements currently in window
        windowLength = right - left + 1

        # Shrink window from n down to k elements
        # tc: O(n - k)
        while windowLength > k:

            # Distance from x of each edge
            leftDistance = abs(arr[left] - x)
            rightDistance = abs(arr[right] - x)

            # Drop the farther num, tie drops right (keeps the smaller value):
            # arr = [1, 2, 3, 4, 5], k = 4
            #   x = 3 -> distances 2 and 2, tie -> drop right -> window [1, 2, 3, 4]
            #   x = 6 -> distances 5 and 1, left is farther -> drop left -> window [2, 3, 4, 5]
            # tc: O(1)
            if leftDistance <= rightDistance:
                right -= 1
            else:
                left += 1

            # Update window length
            windowLength = right - left + 1

        # Window of the k closest elements
        # tc: O(k)
        closest = arr[left:right + 1]

        # overall: tc O(n)
        # overall: sc O(k) for the returned list, O(1) extra
        return closest

    def findClosestElements(self, arr: list[int], k: int, x: int) -> list[int]:

        # Binary Search (Left Boundary Of Fixed Size Window)

        # Search Representation:
        #   - [left, right] is the range of possible start indexes for the window
        #   - A window starting at left covers [left, left + k - 1]
        #   - Starts run from 0 to n - k, since the window must fit inside arr
        #   - Search is done when left == right, one candidate start remains

        # Idea:
        #   - arr is sorted, so the k closest elements form a contiguous window of length k
        #   - Only the start index is unknown, so binary search over starts
        #   - For the window starting at mid, compare its left edge arr[mid]
        #     with the element just past its right edge, arr[mid + k]
        #   - If arr[mid + k] is closer to x, the window should slide right, so left = mid + 1
        #   - Otherwise arr[mid] is closer or tied, so the window should stay or slide left,
        #     keep mid as a candidate with right = mid
        #   - Ties keep the left side, since the problem prefers the smaller value

        # Number of elements
        n = len(arr)

        # Binary Search Boundaries (possible window starts)
        left = 0
        right = n - k

        # tc: O(log(n - k))
        while left < right:

            # Middle start
            mid = (left + right) // 2

            # Distance from x of the window's left edge and the element past its right edge
            leftEdgeDistance = x - arr[mid]
            rightEdgeDistance = arr[mid + k] - x

            # Element past the right edge is closer, slide window right:
            # arr = [1, 2, 3, 4, 5], k = 4, x = 6, left = 0, right = 1, mid = 0
            # leftEdgeDistance = 6 - 1 = 5, rightEdgeDistance = 5 - 6 = -1
            # -1 < 5 -> left = 1
            # tc: O(1)
            if rightEdgeDistance < leftEdgeDistance:
                left = mid + 1

            # Left edge is closer or tied, keep mid as a candidate:
            # arr = [1, 2, 3, 4, 5], k = 4, x = 3, left = 0, right = 1, mid = 0
            # leftEdgeDistance = 3 - 1 = 2, rightEdgeDistance = 5 - 3 = 2
            # 2 is not < 2 -> right = 0
            # tc: O(1)
            else:
                right = mid

        # left == right, one candidate start remains
        # Window of the k closest elements
        # tc: O(k)
        closest = arr[left:left + k]

        # overall: tc O(log(n - k) + k)
        # overall: sc O(k) for the returned list, O(1) extra
        return closest

  oh! pseudocode hasn't been written yet, try another card! :)

    def totalFruit(self, fruits: List[int]) -> int:

        # Sliding Window + Hashmap
        
        # Window Representation:
        #   - HashMap tracks count of fruit within window
        #   - Valid window contains a max of 2 unique fruit

        # Rules:
        #   - Expand variable size window over list by extending right
        #   - Add new fruit to count
        #   - If HashMap has more than 2 unique fruit, shrink window from left until unique fruit is valid again
        #   - For each valid window compare size to max window
        
        # Fruit Count:
        # Holds at most 2 unique fruits at any moment
        # sc: O(1)
        count = defaultdict(int)

        # Window Representation:
        left = 0
        right = 0

        n = len(fruits)

        # Longest string up to now
        maxLen = 0

        # tc: O(n)
        while right < n:

            # Add right num
            rightNum = fruits[right]
            count[rightNum] += 1

            # Shrink from left while window is invalid:
            #   - more than 2 unique fruits in window
            while len(count) > 2:
                
                # Decrease left fruit count
                leftNum = fruits[left]
                count[leftNum] -= 1

                # Remove fruit type if no more fruit remain:
                if count[fruits[left]] == 0:
                    del count[fruits[left]]

                # Shrink window
                left += 1

            # Valid window, compare to max length
            currWindow = right - left + 1
            maxLen = max(maxLen, currWindow)

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return maxLen

    def totalFruit(self, fruits: List[int]) -> int:

        # Sliding Window + Most Recent Index Map

        # Idea:
        #   - Maintain a window [l, r]
        #   - Track last seen index of each fruit type
        #   - If we ever have > 2 fruit types:
        #       remove the fruit with the smallest last seen index
        #       and move left pointer just past it

        mri = {}

        n = len(fruits)-1

        left = 0
        right = 0

        maxLen = 0

        # tc: O(n)
        while right <= n:

            # Update most recent index of current fruit
            mri[fruits[right]] = right

            # Jump from left if window is invalid:
            # - more than 2 unique fruit types, currently 3 types
            if len(mri) > 2:

                # Remove the fruit farthest to the left
                # - jump left to 1 index after farthest fruit
                farthestLeftFruit = min(mri, key=mri.get)
                left = mri[farthestLeftFruit] + 1

                # Remove fruit from map
                del mri[farthestLeftFruit]

            # Valid window, compare to max
            currLen = right - left + 1
            maxLen = max(maxLen, currLen)

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(n)
        return maxLen

Sol 1: MRI HashMap With Jumping Left
1. (mri = {})
2. (left, right = 0, 0)
3. (maxLen = 0)
4. (n = len(s)-1)
5. while right <= n:
   a. newChar = s[right]
   b. if newChar in mri:
         prevIndex = mri[newChar]
         if left <= prevIndex <= right: 
             left = prevIndex + 1
   c. mri[newChar] = right
   d. currLen = right - left + 1
   d. maxLen = max(maxLen, currLen)
   e. right += 1
6. return maxLen

Solution 2: Window HashSet Tracking Chars With Removal
1. (window = {}) 
2. (left, right = 0, 0)
3. (maxLen = 0)
4. (n = len(s)-1)
5. while right < n:
   a. newChar = s[right]
   b. while newChar in window:
         window.remove(s[left])
         left += 1
   c. window.add(newChar)
   d. maxLen = max(maxLen, len(window))
   e. right += 1
6. return maxLen

    def lengthOfLongestSubstring(self, s: str) -> int:

        # Sliding Window (Variable Size)

        # Window Representation:
        #   - HashSet contains most recent index of all chars encountered
        #   - Window boundaries kept via [left, right]
        #   - Valid window contains no duplicate characters

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - If new character results in a duplicate,
        #     move the left window boundary to 1 in front of the duplicate
        #   - For each valid window compare size to max window

        n = len(s)-1

        # Track more recent index appearance for char
        mri = {} 

        # Sliding Window Variables
        # left and right boundary of substring
        left = 0
        right = 0

        # max length so far
        maxLen = 0

        # tc: O(n)
        while right <= n:
                
                # Character we just added to substring
                newChar = s[right]

                # If we have encountered character already
                if newChar in mri:
                    
                    # Grab index of previous encounter
                    prevIndex = mri[newChar]
                    
                    # Jump from left if window is invalid:
                    # - jump left to 1 index after duplicate
                    if left <= prevIndex <= right:
                        left = prevIndex + 1

                # Update most recent index for character
                mri[newChar] = right

                # Valid window, compare to max
                currLen = right - left + 1
                maxLen = max(maxLen, currLen)

                # Iterate window
                right += 1
            
        # overall: tc O(n)
        # overall: sc O(min(n, k))
        return maxLen

    def lengthOfLongestSubstring(self, s: str) -> int:

        # Sliding Window HashSet Right Left Representation (Variable Size Window)

        # Window Representation:
        #   - Set() contains chars within window [left, right]    
        #   - Numbers enter and exit window via left and right
        #   - Valid window contains no duplicate characters

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - If duplicate found, shrink window from left until duplicate is removed
        #   - For each valid window compare size to max window

        n = len(s)

        # Sliding Window Data:
        # sc: O(n)
        window = set()

        # Sliding Window Boundaries:
        left = 0
        right = 0

        # Track longest valid window
        maxLen = 0

        # tc: O(n)
        while right < n:

            # Grab char we want to add
            newChar = s[right]

            # Shrink from left while window is invalid:
            # - if duplicate exists in window set
            # tc: O(n)
            while newChar in window:
                window.remove(s[left])
                left += 1

            # Add char to window
            window.add(newChar)

            # Compare valid window length to max
            maxLen = max(maxLen, len(window))

            # Expand valid window
            right += 1

        # overall: tc O(n)
        # overall: sc O(min(n, k))
        return maxLen

  oh! pseudocode hasn't been written yet, try another card! :)

    def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
        
        # Sliding Window + Two Pointers
        
        # Substring Representation:
        #   - Cost tracks cost to change every character in s to match t
        #   - Valid window has a windowChangeCost <= maxCost

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Add new char cost to change s[right] -> t[right] to current total window cost
        #   - If cost exceeds budget, shrink window from left until cost is valid again
        #   - For each valid window compare size to max window

        n = len(s)
        
        # Sliding Window Variables
        left = 0
        right = 0
        maxLen = 0

        # Cost to change entire current window from s -> t
        windowChangeCost = 0

        # tc: O(n)
        while right < n: 

            # Add new char cost to window cost:
            # - cost of single char from s -> t
            rightCharS = s[right]
            rightCharT = t[right]
            cost = abs(ord(rightCharS) - ord(rightCharT))
            windowChangeCost += cost

            # Shrink from left while window is invalid:
            # - curr cost to change entire window is higher than budget
            while maxCost < windowChangeCost:

                # Remove old character and save cost from window cost:
                # - cost of single char from s -> t
                leftCharS = s[right]
                leftCharT = t[right]
                saving = abs(ord(s[left]) - ord(t[left]))
                windowChangeCost -= saving

                # Shrink window
                left += 1
            
            # Valid window, compare to max
            windowLen = (right - left) + 1
            maxLen = max(maxLen, windowLen)

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return maxLen

  oh! pseudocode hasn't been written yet, try another card! :)

    def longestOnes(self, nums: List[int], k: int) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Zero tracks total flips needed for substring to be consecutive 1's
        #   - Valid window only has consecutive 1's
        #   - Valid window has zeroCount <= k

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Add new int to zero count
        #   - If zeroCount exceeds budget, shrink window from left until num of zeros is valid again
        #   - For each valid window compare size to max window

        n = len(nums)-1

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Number of zeros in current window
        zeroCount = 0

        # Longest valid window seen
        maxLen = 0

        # tc: O(n)
        while right <= n:

            # Update zero count:
            if nums[right] == 0:
                zeroCount += 1

            # Shrink from left while window is invalid:
            #   - num of 0's must be <= k
            # tc: O(1) amortized
            while k < zeroCount:

                # Update count
                if nums[left] == 0:
                    zeroCount -= 1
                left += 1

            # Validate window, compare size to max
            currWindow = right - left + 1
            maxLen = max(maxLen, currWindow)

        # overall: tc O(n)
        # overall: sc O(1)
        return maxLen

Sol 1: HashMap Tracking CharCount To Find MostOccur
1. (charCount = {}) 
2. (left, right = 0, 0)  
3. (mostOccur = 0) 
4. (maxLen = 0)
2. while right < n:
   a. charCount[s[right]] += 1
   b. mostOccur = max(mostOccur, charCount[s[right]])
   c. currWindowLen = right - left + 1
   d. allOtherChars = currWindowLen - mostOccur
   e. while k < allOtherChars:
        charCount[s[left]] -= 1
        left += 1
        currWindowLen = right - left + 1
        allOtherChars = currWindowLen - mostOccur
   f. maxLen = max(maxLen, currWindowLen)
   g. right += 1
3. return maxLen

    def characterReplacement(self, s: str, k: int) -> int:
        
        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - HashMap tracks char count within window
        #   - Valid window contains a single consecutive character
        #   - Valid window changes at most k characters from c -> seqChar

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Add new char to count
        #   - mostOccur is total count of the most occurring character in the window
        #   - allOtherChars is the total count of all other characters in the window
        #   - If allOtherChars is more than the char change budget k, shrink window from left until allOtherChars <= k

        n = len(s)

        # char count within window boundaries
        count = defaultdict(int)

        # Sliding Window Variables
        # sc: O(1)
        # left and right window boundaries
        left = 0
        right = 0

        # Sliding Window Data
        # sc: O(1)
        # mostOccur: most occurring character in window
        mostOccur = 0  
        # max length seen so far
        maxLen = 0

        # tc: O(n)
        while right < n:

            # Character we just encountered
            # tc: O(1)
            currChar = s[right]
            charCount[currChar] += 1

            # Update mostOccur in window
            # tc: O(1)
            mostOccur = max(mostOccur, charCount[currChar])

            # length of curr window
            currWindowLen = right - left + 1

            # how many other chars exists, (anything that is not mostOccur)
            allOtherChars = currWindowLen - mostOccur

            # Shrink from left while window is invalid:
            # We need allOtherChars to be less than k (num of chars we can replace),
            # so that we can replace allOtherChars with the mostOccur.
            # thus, shrink window from left by 1 until allOtherChars is valid
            # tc: O(1) amortized
            while k < allOtherChars:

                # Do NOT update mostOccur here:
                #   - while shrinking, the mostOccur may become stale and decreased
                #   - mostOccur may have shifted to a different character

                # This is fine because:
                #   - for window [left:right], we have agreed 
                #     that mostOccur is highest char up to right
                #   - A stale mostOccur will under estimate allOtherChars 
                
                # This is safe because: 
                #   - No char can exceed the current mostOccur while shrinking,
                #     we are only shrinking the window so counts can only go down
                
                # Thus during shrink, mostOccur:
                #   - not acting as a true most occurring character
                #   - acting as a flag for the original mostOccur for original window
                #     that existed before shrinking
                
                # Remove left character from window
                charCount[s[left]] -= 1

                left += 1

                # Recompute currWindowLen and allOtherChars after shrink
                currWindowLen = right - left + 1
                allOtherChars = currWindowLen - mostOccur

            # Once allOtherChars is valid, check maxLen
            maxLen = max(maxLen, currWindowLen)

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return maxLen

  oh! pseudocode hasn't been written yet, try another card! :)

    def minSubArrayLen(self, target: int, nums: List[int]) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Running count tracks sum of window
        #   - Valid window has sum greater than or equal to target

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Add new value to running sum
        #   - All nums are positive, sum always increases when extending and decreases when shrinking
        #   - If sum exceeds target, shrink from left until sum is valid again
        #   - For each valid window compare size to max window

        n = len(nums)

        left = 0

        # Sum of current window
        runningSum = 0
        
        minLen = float('inf')

        # tc: O(n)
        for right in range(n):

            # Add num to running count
            windowSum += nums[right]

            # Shrink from left while window is valid:
            # - windowSum meets or exceeds target
            # tc: O(1) amortized
            while target <= windowSum:

                # Valid window, compare to min length 
                currWindowLen = right - left + 1
                minLen = min(minLen, currWindowLen)

                # Remove left num from window sum
                windowSum -= nums[left]

                # Shrink window
                left += 1

        # No valid window was found
        if minLen == float('inf'):
            return 0
        
        # overall: tc O(n)
        # overall: sc O(1)
        return minLen

  oh! pseudocode hasn't been written yet, try another card! :)

    def checkInclusion(self, s: str, t: str) -> bool:

        # Sliding Window (Fixed Size Window)

        # Window Representation:
        #   - Two Hashmaps:
        #       needleFreq -> required counts
        #       windowFreq -> counts in current window
        #   - Valid window has equal char counts needle chars between needle and window freq

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Track how many required character are satisfied via needleFreq
        #   - Add new char count to windowFreq
        #   - While chars between needle and window freq are satisfied, 
        #     shrink from left to minimize window
        #   - For each valid window compare size to min window

        # haystack < needle: 
        # If haystack is smaller than needle, 
        # substring is not possible
        if len(s) < len(t):
            return ""

        # Build needle character map
        # sc: O(m)
        needleCharCount = defaultdict(int)
        for c in t:
            needleCharCount[c] += 1

        # Sliding Window Variables
        left = 0
        right = 0

        # Char count for current window
        windowCharCount = defaultdict(int)

        # Length and starting index for min window
        minLen = float('inf')
        minStart = 0

        # Flags for unique chars slots from needle hashmap length
        needCharSlots = len(needleCharCount) 
        haveCharSlots = 0                 

        # tc: O(n)
        for right in range(len(s)):

            # Expand window
            rightChar = s[right]
            windowCharCount[rightChar] += 1

            # If char is a specific slot char
            if rightChar in needleCharCount:

                # If char has met requirements
                if windowCharCount[rightChar] == needleCharCount[rightChar]:
                    haveCharSlots += 1


            # Shrink from left while window is valid:
            #   - All specific slot chars have met requirements
            while haveCharSlots == needCharSlots:
                
                # Valid window, compare to min
                windowLen = right - left + 1                
                if windowLen < minLen:
                    minLen = windowLen
                    minStart = left

                # Remove left character
                leftChar = s[left]
                windowCharCount[leftChar] -= 1
                
                # If char is a slot char with requirements
                if leftChar in needleCharCount:

                    # If char no longer meets requirements
                    if  windowCharCount[leftChar] < needleCharCount[leftChar]:
                        haveCharSlots -= 1

                # Shrink window
                left += 1

        # If no valid substring was found
        if minLen == float("inf"):
            return ""

        # Grab min substring
        res = s[minStart:minStart + minLen]

        # overall: tc O(n + m)
        # overall: sc O(n)
        return res

    def minWindow(self, s: str, t: str) -> str:

        # Sliding Window (Variable Size Window)

        # Substring Representation:
        #   - One HashMap: 
        #       char -> remaining required count
        #   - targetCharsRemaining: tracks total chars with requirements still needed

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Update char remaining needed count
        #   - 
        #   - Decrease count of remaining required count
        #   - When targetCharsRemaining == 0, window is valid
        #   - Shrink from left to minimize window
        #   - Track smallest valid window

        # Needle is longer than haystack:
        # substring not possible
        if len(s) < len(t):
            return ""

        # Build required frequency map
        windowCharCount = defaultdict(int)
        for ch in t:
            windowCharCount[ch] += 1

        # Total chars still needed
        globalRemainingCountAcrossChars = len(t)         

        # Sliding Window Variables
        left = 0
        right = 0

        # Min window substring
        minWindowRight = float('inf')
        minWindowLeft = 0          

        # tc: O(n)
        for right in range(len(s)):

            # Expand window
            rightChar = s[right]
            
            # windowCharCount:
            # To start, hashmap will contains:
            #   - positive values of required needle chars
            #   - all other possible keys are set to 0
            # Moving forward, all other possible keys will 
            # always be less than or equal to 0 (regardless of adding or removing).
            # Thus, to track chars that are in the needle,
            # we only count chars that at some point have a positive count,
            # to contribute towards decreasing or increasing the global remaining 
            stillNeedThisMany = windowCharCount[rightChar]

            if stillNeedThisMany > 0:
                globalRemainingCountAcrossChars -= 1

            # Increase char count for windowCharCount 
            # regardless of it being a required or non-required char,
            # both cases covered per above
            windowCharCount[rightChar] -= 1

            # Shrink from left while window is valid:
            #   - Total needle char count is covered
            # tc: amortized O(n)
            while globalRemainingCountAcrossChars == 0:

                # Valid window, compare to min
                currWindowLen = right - left + 1
                minWindowLen = minWindowRight - minWindowLeft + 1
                if currWindowLen < minWindowLen:
                    minWindowRight = right
                    minWindowLeft = left

                # Remove left character, and to char required count,
                # again per above:
                #   - required needle chars have a positive required count
                #   - non-required chars have a required count of 0
                leftChar = s[left]
                windowCharCount[leftChar] += 1

                # If this char has a positive required count:
                #   - it is a required needle char
                #   - we need one more copy of the char, since we just lost a occurrence of it
                #   - add to global need count
                stillNeedThisMany = windowCharCount[leftChar]

                if stillNeedThisMany > 0:
                    globalRemainingCountAcrossChars += 1

                # Shrink window
                left += 1

        # No valid window was found
        if minWindowRight == float("inf"):
            return ""

        # Grab min window
        res = s[minWindowLeft:minWindowRight + 1]

        # overall: tc O(n + m)
        # overall: sc O(n)
        return res

  oh! pseudocode hasn't been written yet, try another card! :)

    def balancedString(self, s: str) -> int:

        # Sliding Window (Variable Size Window)

        # String Representation:
        #   - HashMap tracks char count OUTSIDE window
        #   - Valid window makes up for uneven outside count by changing chars INSIDE the window

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Remove chars from OUTSIDE count when they enter the window
        #   - Once all outside frequencies <= target, window is valid
        #   - For each valid window compare size to min window
        
        #   s = "QQWE", target = 1
        #   outsideCount = {Q:2, W:1, E:1, R:0}
        
        # When window is at the first Q,
        # that Q is remove from the OUTSIDE char count,
        # leaving the max(outsideCount.values()) -> 1
        # which is equal to the target == 1,
        # meaning that the current window is the smallest possible section
        # we can replace to make the entire string balanced

        n = len(s)

        # Target char count:
        #   - s length is multiple of 4, and has 4 possible characters (Q W E R)
        #   - balanced s has each char appear n // 4 times
        target = n // 4

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Outside HashMap:
        #   - Stores frequencies of chars OUTSIDE current window
        outsideCount = defaultdict(int)
        for c in s:
            outsideCount[c] += 1

        # Minimum valid window size
        minLen = float('inf')

        # Balanced Check:
        #   - Current window length is 0
        #   - All chars are outside the window (we are checking the original string)
        #   - If balanced value == target, then the string is already balanced
        # tc: O(1)
        if max(outsideCount.values()) == target:
            return 0

        # Expand sliding window
        # tc: O(n)
        for right in range(n):

            # Add char to window,
            # remove new char from OUTSIDE count
            rightChar = s[right]
            outsideCount[rightChar] -= 1

            # Shrink from left while window is valid: 
            #   - OUTSIDE count balanced value is equal to the target  
            #   - string is balanced
            #   - left has not passed right (left and catch up to right, leaving a window length of 1)
            # tc: O(1) amortized
            while left <= right and max(outsideCount.values()) == target:

                # Valid window, compare to min
                currWindowLen = right - left + 1
                minLen = min(minLen, currWindowLen)

                # Remove char from window,
                # add char back to OUTSIDE count
                leftChar = s[left]
                outsideCount[leftChar] += 1

                # Shrink window
                left += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return minLen

  oh! pseudocode hasn't been written yet, try another card! :)

    def numberOfSubstrings(self, s: str) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - HashMap stores frequency of each char in current window
        #   - Window is valid when it contains at least one of each: a, b, c

        # Idea:
        #   - Expand right to add new characters
        #   - Once window is valid (has all 3 chars), shrink from left
        #     to find the smallest valid window ending at right
        #   - Every starting index from [0, left-1] also forms a valid substring
        #     ending at right, since adding more chars to the left keeps it valid
        #   - So add left to result at each right

        n = len(s)-1

        # HashMap: char -> frequency in current window
        # sc: O(1) at most 3 chars
        count = defaultdict(int)

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Total valid substrings found
        subarrayCount = 0

        # tc: O(n)
        while right <= n:

            # Add char count to window
            count[s[right]] += 1

            # Shrink from left while window is valid:
            # - window contains all 3 chars
            while True:

                # Check if window contains all 3 characters
                windowValid = True
                for c in "abc":
                    if count[c] <= 0:
                        windowValid = False
                        break

                # Stop Shrinking
                if not windowValid:
                    break

                # Decrease char count
                count[s[left]] -= 1

                # Shrink window
                left += 1

            # Include all valid subarrays from 0 to left:
            # [z, z, z, a b c] -> left is set to index 4, when window becomes invalid
            # so there are 4 valid subarrays
            # tc: O(1)
            subarrayCount += left

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return subarrayCount

    def numberOfSubstrings(self, s: str) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - HashMap stores frequency of each char in current window
        #   - Window is valid when it contains at least one of each: a, b, c

        # Idea:
        #   - Expand right to add new characters
        #   - Once window is valid (has all 3 chars), count every end that
        #     keeps this start valid, then shrink from left
        #   - Window [left..right] is valid, so with the same start,
        #     [left..right+1], [left..right+2], ... [left..n-1] are also valid,
        #     since adding more chars to the right keeps it valid
        #   - So add n - right to result for each valid start

        n = len(s)

        # HashMap: char -> frequency in current window
        # sc: O(1) at most 3 chars
        count = defaultdict(int)

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Total valid substrings found
        subarrayCount = 0

        # tc: O(n)
        while right < n:

            # Add char count to window
            count[s[right]] += 1

            # Shrink from left while window is valid:
            # - window contains all 3 chars
            while True:

                # Check if window contains all 3 characters
                windowValid = True
                for c in "abc":
                    if count[c] <= 0:
                        windowValid = False
                        break

                # Stop Shrinking
                if not windowValid:
                    break

                # Include all valid subarrays starting at left:
                # [a b c z z z] -> left = 0, right = 2, n = 6
                # ends at 2, 3, 4, 5 are all valid
                # so there are n - right = 4 valid subarrays
                # tc: O(1)
                subarrayCount += n - right

                # Decrease char count
                count[s[left]] -= 1

                # Shrink window
                left += 1

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return subarrayCount

    def numberOfSubstrings(self, s: str) -> int:

        # Last Seen Index Tracking (Single Pass)

        # Representation:
        #   - Track the last seen index of each char: a, b, c
        #   - Valid window contains all 3 chars

        # Idea:
        #   - Expand variable size window over list by extending right
        #   - Ignore all other chars
        #   - Update abc index to mri
        #   - All valid windows start at the left most mri after full iteration

        n = len(s) - 1

        # Init mri to -1,
        # if char is never encountered then count results in 0
        mriA = mriB = mriC = -1

        # Total valid substrings found
        count = 0

        right = 0

        # tc: O(n)
        while right <= n:

            # Update last seen index for current char
            if s[i] == 'a':
                mriA = i
            elif s[i] == 'b':
                mriB = i
            elif s[i] == 'c':
                mriC = i

            # Leftmost mri:
            # [z, z, z, a b c] -> mri for a is 3, 
            # so there are 3 + 1 = 4 subarrays with all 4 chars
            count += min(mriA, mriB, mriC) + 1

            # Extend window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return count

  oh! pseudocode hasn't been written yet, try another card! :)

    def countGood(self, nums: List[int], k: int) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - HashMap stores frequency of each num in current window
        #   - pairs tracks number of equal-value index pairs (i < j) in current window
        #   - Window is valid when pairs >= k

        # Idea:
        #   - "At least k pairs" is monotonic under extension:
        #       adding a num can only add pairs, so a valid window stays valid when extended
        #   - Expand right to add new nums
        #   - Adding a num with c existing copies creates c new pairs
        #   - Shrink from left while window is valid (pairs >= k) until it becomes invalid
        #   - Removing a num with c remaining copies destroys c pairs
        #   - Every starting index from [0, left-1] forms a valid subarray
        #     ending at right, since adding more nums to the left keeps it valid
        #   - So add left to result at each right

        n = len(nums)

        # HashMap: num -> frequency in current window
        # sc: O(n)
        count = defaultdict(int)

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Equal-value index pairs in current window
        pairs = 0

        # Total valid subarrays
        subarrayCount = 0

        # tc: O(n)
        while right < n:

            # Add right num to window
            # - each existing copy forms a new pair with it
            # - read count before incrementing, a num can't pair with itself
            rightNum = nums[right]
            pairs += count[rightNum]
            count[rightNum] += 1

            # Shrink from left while window is valid:
            # - at least k pairs in window
            # tc: O(1) amortized
            while pairs >= k:

                # Remove left num from window
                # - decrement first, remaining copies are the pairs lost
                leftNum = nums[left]
                count[leftNum] -= 1
                pairs -= count[leftNum]

                # Shrink window
                left += 1

            # Include all valid subarrays ending at right:
            # nums = [1, 1, 1, 1, 1], k = 3, right = 3
            # shrink loop stops with left = 2 (window [1, 1] has only 1 pair)
            # starts 0 and 1 are valid:
            #   [1, 1, 1, 1], [1, 1, 1]
            # so there are left = 2 valid subarrays
            #
            # tc: O(1)
            subarrayCount += left

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(n)
        return subarrayCount

    def countGood(self, nums: List[int], k: int) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - HashMap stores frequency of each num in current window
        #   - pairs tracks number of equal-value index pairs (i < j) in current window
        #   - Window is valid when pairs >= k

        # Idea:
        #   - "At least k pairs" is monotonic under extension:
        #       adding a num can only add pairs, so a valid window stays valid when extended
        #   - Expand right to add new nums
        #   - Adding a num with c existing copies creates c new pairs
        #   - Once window is valid (pairs >= k), count every end that
        #     keeps this start valid, then shrink from left
        #   - Window [left..right] is valid, so with the same start,
        #     [left..right+1], [left..right+2], ... [left..n-1] are also valid,
        #     since adding more nums to the right keeps it valid
        #   - Removing a num with c remaining copies destroys c pairs
        #   - So add n - right to result for each valid start

        n = len(nums)

        # HashMap: num -> frequency in current window
        # sc: O(n)
        count = defaultdict(int)

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Equal-value index pairs in current window
        pairs = 0

        # Total valid subarrays
        subarrayCount = 0

        # tc: O(n)
        while right < n:

            # Add right num to window
            # - each existing copy forms a new pair with it
            # - read count before incrementing, a num can't pair with itself
            rightNum = nums[right]
            pairs += count[rightNum]
            count[rightNum] += 1

            # Shrink from left while window is valid:
            # - at least k pairs in window
            # tc: O(1) amortized
            while pairs >= k:

                # Include all valid subarrays starting at left:
                # nums = [1, 1, 1, 1, 1], k = 3, n = 5
                # left = 0, right = 2
                # ends at 2, 3, 4 are all valid:
                #   [1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1, 1]
                # so there are n - right = 5 - 2 = 3 valid subarrays
                #
                # tc: O(1)
                subarrayCount += n - right

                # Remove left num from window
                # - decrement first, remaining copies are the pairs lost
                leftNum = nums[left]
                count[leftNum] -= 1
                pairs -= count[leftNum]

                # Shrink window
                left += 1

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(n)
        return subarrayCount

  oh! pseudocode hasn't been written yet, try another card! :)

    def countSubarrays(self, nums: List[int], k: int) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - maxCount tracks occurrences of the global max element in window
        #   - Window is valid when maxCount >= k

        # Idea:
        #   - Find global maximum element
        #   - Expand right to add new nums
        #   - Once window is valid (max appears at least k times), shrink from left
        #     until the window becomes invalid
        #   - Every starting index from [0, left-1] forms a valid subarray
        #     ending at right, since adding more nums to the left keeps it valid
        #   - So add left to result at each right

        n = len(nums)

        # Global maximum element
        maxNum = max(nums)

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Occurrences of maxNum in current window
        maxCount = 0

        # Total valid subarrays
        subarrayCount = 0

        # tc: O(n)
        while right < n:

            # Add right num to window
            if nums[right] == maxNum:
                maxCount += 1

            # Shrink from left while window is valid:
            # - max element appears at least k times
            # tc: O(1) amortized
            while maxCount >= k:

                # Remove left num from window
                if nums[left] == maxNum:
                    maxCount -= 1

                # Shrink window
                left += 1

            # Include all valid subarrays ending at right:
            # nums = [1, 3, 3], k = 2, right = 2
            # shrink loop stops with left = 2 (window [3] has only one 3)
            # starts 0 and 1 are valid -> [1, 3, 3], [3, 3]
            # so there are left = 2 valid subarrays
            # tc: O(1)
            subarrayCount += left

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return subarrayCount

    def countSubarrays(self, nums: List[int], k: int) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - maxCount tracks occurrences of the global max element in window
        #   - Window is valid when maxCount >= k

        # Idea:
        #   - Find global maximum element
        #   - Expand right to add new nums
        #   - Once window is valid (max appears at least k times), count every end
        #     that keeps this start valid, then shrink from left
        #   - Window [left..right] is valid, so with the same start,
        #     [left..right+1], [left..right+2], ... [left..n-1] are also valid,
        #     since adding more nums to the right keeps it valid
        #   - So add n - right to result for each valid start

        n = len(nums)

        # Global maximum element
        maxNum = max(nums)

        # Sliding Window Boundaries
        left = 0
        right = 0

        # Occurrences of maxNum in current window
        maxCount = 0

        # Total valid subarrays
        subarrayCount = 0

        # tc: O(n)
        while right < n:

            # Add right num to window
            if nums[right] == maxNum:
                maxCount += 1

            # Shrink from left while window is valid:
            # - max element appears at least k times
            # tc: O(1) amortized
            while maxCount >= k:

                # Include all valid subarrays starting at left:
                # nums  = [3, 3, 1], k = 2, n = 3
                # index =  0  1  2
                #          ^  ^
                #          l  r
                #
                # ends at 1, 2 are valid
                # so there are n - right = 3 - 1 = 2 valid subarrays
                #
                #   [0..1] = [3, 3]       two 3's => valid
                #   [0..2] = [3, 3, 1]    two 3's => valid
                #
                # tc: O(1)
                subarrayCount += n - right

                # Remove left num from window
                if nums[left] == maxNum:
                    maxCount -= 1

                # Shrink window
                left += 1

            # Iterate window
            right += 1

        # overall: tc O(n)
        # overall: sc O(1)
        return subarrayCount

  oh! pseudocode hasn't been written yet, try another card! :)

    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:

        # Sliding Window + Running Product

        # Window Representation:
        #   - Product tracks product of current window
        #   - Valid window has a product <= k

        # Rules:
        #   - Expand variable size window over list by extending right
        #   - Multiple new num into running product
        #   - If product is greater than k, shrink window from left until product is valid again 
        #   - For each valid window compare size to max window

        # Early Exit:
        # No array can have a product less than 1,
        # since int values are guaranteed to be 1 <= int
        if k <= 1:
            return 0

        # Sliding window boundaries
        left = 0

        # Running product of current window
        runningProduct = 1

        # Total valid subarrays
        validArrayCount = 0

        # Expand right boundary
        # tc: O(n)
        for right in range(len(nums)):

            # Include current element into window
            runningProduct *= nums[right]

            # Shrink from left while window is invalid:
            # - runningProduct < k
            # tc: O(1) amortized
            while runningProduct >= k:

                # Remove left element from runningProduct
                runningProduct //= nums[left]

                # Shrink window
                left += 1

            # Add all valid subarray ending at right,
            # all other subarrays are counted at different iterations
            arraysEndingAtRight = right - left + 1
            validArrayCount += arraysEndingAtRight

        # overall: tc O(n)
        # overall: sc O(1)
        return validArrayCount

  oh! pseudocode hasn't been written yet, try another card! :)

    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:

        # Sliding Window (Variable Size Window)

        # Window Representation:
        #   - Maintain window [left, right]
        #   - windowSum tracks sum of nums in current window
        #   - Window is valid when its sum is at most currGoal

        # Idea:
        #   - "Exactly k" is not monotonic under extension, so left / n - right do NOT apply
        #   - Split it into two "at most" problems:
        #       exactly k = atMost(k) - atMost(k-1)
        #   - "At most" IS monotonic under shrinking:
        #       nums are 0 or 1 (never negative), so removing a num never raises the sum
        #       and a valid window stays valid when shrunk inward
        #   - Expand right to add new nums
        #   - Shrink from left while window is invalid (sum too large)
        #   - Every starting index from [left, right] forms a valid subarray
        #     ending at right, since removing nums from the left keeps it valid
        #   - So add right - left + 1 to result at each right

        # Why the split works:
        #   - atMost(k)   counts subarrays with sum 0, 1, 2, ... k
        #   - atMost(k-1) counts subarrays with sum 0, 1, 2, ... k-1
        #   - subtracting leaves only subarrays with sum exactly k

        # Window Example:
        #   nums = [1, 0, 1, 0, 1], k = 2
        #
        #   atMost(2): all windows with sum <= 2
        #   [1, 0, 1, 0, 1]
        #    LR              sum=1, res += 1
        #    L  R            sum=1, res += 2
        #    L     R         sum=2, res += 3
        #    L        R      sum=2, res += 4
        #    L           R   sum=3 > 2, shrink -> left=1, sum=2, res += 4
        #   atMost(2) = 14
        #
        #   atMost(1): all windows with sum <= 1
        #   [1, 0, 1, 0, 1]
        #    LR              sum=1, res += 1
        #    L  R            sum=1, res += 2
        #    L     R         sum=2 > 1, shrink -> left=1, sum=1, res += 2
        #       L     R      sum=1, res += 3
        #       L        R   sum=2 > 1, shrink -> left=3, sum=1, res += 2
        #   atMost(1) = 10
        #
        #   exactly(2) = atMost(2) - atMost(1) = 14 - 10 = 4
        #   valid subarrays: [1,0,1], [1,0,1,0], [0,1,0,1], [1,0,1]

        # Count of subarrays with sum at most currGoal
        def atMost(currGoal: int) -> int:

            # No subarray has a negative sum (happens when goal = 0)
            if currGoal < 0:
                return 0

            n = len(nums)

            # Sliding Window Boundaries
            left = 0
            right = 0

            # Sum of nums in current window
            # sc: O(1)
            windowSum = 0

            # Total valid subarrays with sum at most currGoal
            subarrayCount = 0

            # tc: O(n)
            while right < n:

                # Add right num to window
                windowSum += nums[right]

                # Shrink from left while window is invalid:
                # - sum is greater than currGoal
                # tc: O(1) amortized
                while windowSum > currGoal:

                    # Remove left num from window
                    windowSum -= nums[left]

                    # Shrink window
                    left += 1

                # Include all valid subarrays ending at right:
                # [left..right] is the largest valid window ending at right,
                # and shrinking it keeps it valid, so every start from
                # left to right works
                #
                # nums = [1, 0, 1, 0, 1], currGoal = 2, right = 3, left = 0
                # starts 0, 1, 2, 3 are valid:
                #   [1, 0, 1, 0], [0, 1, 0], [1, 0], [0]
                # so there are right - left + 1 = 3 - 0 + 1 = 4 valid subarrays
                #
                # Note: this is the mirror of "+= left" (at least k):
                #   at least k: valid starts are 0 ... left-1     -> left
                #   at most k:  valid starts are left ... right   -> right - left + 1
                #
                # tc: O(1)
                subarrayCount += right - left + 1

                # Iterate window
                right += 1

            # tc: O(n)
            # sc: O(1)
            return subarrayCount

        # atMost(k):   counts all subarrays with sum <= k
        # atMost(k-1): counts all subarrays with sum <= k-1
        # Subtracting leaves only subarrays with sum exactly k
        res = atMost(k) - atMost(k - 1)

        # overall: tc O(n)
        # overall: sc O(1)
        return res