Array Form
    Index:  0   1   2   3   4   5   6
    Value: [3,  5,  8,  9, 10, 12, 15]

    Tree Form

            (0)3
            /     \
        (1)5       (2)8
        /   \      /   \
    (3)9  (4)10 (5)12 (6)15

    def kthLargest(nums, k):
        heap = []
        for num in nums:
            heapq.heappush(heap, num)
            if len(heap) > k:
                heapq.heappop(heap)  # Keep only top K elements
        return heap[0]

    # Example: kthLargest([3, 2, 1, 5, 6, 4], 2) -> 5

class MedianFinder:
    def __init__(self):
        self.low = []   # Max-heap (invert values)
        self.high = []  # Min-heap
    
    def addNum(self, num: int) -> None:
        heapq.heappush(self.low, -num)
        heapq.heappush(self.high, -heapq.heappop(self.low))
        if len(self.low) < len(self.high):
            heapq.heappush(self.low, -heapq.heappop(self.high))
    
    def findMedian(self) -> float:
        if len(self.low) > len(self.high):
            return -self.low[0]
        return (-self.low[0] + self.high[0]) / 2        

    def mergeKSorted(lists):
        heap = []
        for i, lst in enumerate(lists):
            if lst:
                heapq.heappush(heap, (lst[0], i, 0))
        
        result = []
        while heap:
            val, list_idx, elem_idx = heapq.heappop(heap)
            result.append(val)
            if elem_idx + 1 < len(lists[list_idx]):
                heapq.heappush(heap, (lists[list_idx][elem_idx+1], list_idx, elem_idx+1))
        return result

    # mergeKSorted([[1,4,5],[1,3,4],[2,6]]) -> [1,1,2,3,4,4,5,6]   

def dijkstra(graph, start):
    
    # Graph: Node -> list of (neighbor, weight) tuples
    # start: Starting node for shortest path search

    # Result: 
    # dist: shortest distance from start to all other nodes

    # Init all distances to infinity, 
    # except start node which has distance 0
    dist = {node: float('inf') for node in graph}
    dist[start] = 0

    # minHeap priority queue stores tuples of (distance, node)
    # iterate from start node and commence exploring neighbors
    heap = [(0, start)]

    # while there are nodes to process in heap
    while heap:
        
        # grab node with smallest known distance from start
        d, node = heapq.heappop(heap)

        # Skip if we already have already explored a shorter
        # path to the current node
        if d > dist[node]:
            continue

        # Check each neighbor and see if we have found 
        # a shorter path through the current node
        for nei, w in graph[node]:
            
            # grab new distance
            nd = d + w

            # if shorter path found, update and push to heap
            if nd < dist[nei]:
                dist[nei] = nd
                heapq.heappush(heap, (nd, nei))

    # overall: time complexity
    # overall: space complexity
    return dist

    def max_sliding_window(nums, k):

        # maxHeap via minHeap with negative values
        # initialize with first k elements
        heap = [(-nums[i], i) for i in range(k)]
        heapq.heapify(heap)

        # root of heap is the largest in the current window
        res = [-heap[0][0]]
        
        # iterate sliding window forward
        for i in range(k, len(nums)):

            # push new element to heap
            heapq.heappush(heap, (-nums[i], i))

            # remove top element if they are outside current window
            while heap[0][1] <= i - k:
                heapq.heappop(heap)

            # after removing out of window elements, heap root is max
            # within the current window
            res.append(-heap[0][0])

        return res

    def minMeetingRooms(intervals):

        # Sort intervals by their start time,
        # ensures we process meetings in chronological order
        intervals.sort(key=lambda x: x[0])

        # minHeap to track end time of ongoing meetings,
        # storing the earliest ending meeting at the top
        heap = []

        # iterate over rooms in earliest starting order
        for start, end in intervals:

            # if heap is not empty, and the earliest ending meeting the earliest meeting ends
            # ends before or exactly when the new meeting starts,
            # then we can remove the earliest ending meeting 
            # (essentially freeing up a room)
            if heap and heap[0] <= start:
                # pop meeting that ended the earliest
                heapq.heappop(heap)

            # 'start' the current meeting by pushing it to the heap
            heapq.heappush(heap, end)

        # last heap size is the number meetings running
        # concurrently after all meetings have started
        return len(heap)

    # Example: 
    # minMeetingRooms([[0,30],[5,10],[15,20]]) -> 2

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

    def findKthLargest(self, nums: list[int], k: int) -> int:

        # MinHeap (Fixed Size K)

        # Heap Representation:
        #   - Maintain a minHeap holding the k largest elements seen so far
        #   - Root (minHeap[0]) is the smallest of those k elements,
        #     which is exactly the kth largest element overall
        #   - Heap is valid when it holds at most k elements

        # Idea:
        #   - The kth largest element is the smallest of the top k elements
        #   - Keep only the top k elements in a minHeap, so the root is always the answer
        #   - If the heap has fewer than k elements, push the new num
        #   - If the heap is full, the new num only matters if it beats the root,
        #     since anything smaller can never be in the top k
        #   - Replace the root with the new num to evict the old kth largest
        #   - After every num has been seen, the root is the answer

        # MinHeap of the k largest elements seen so far
        minHeap = []

        # Array Pointer
        index = 0

        # tc: O(n log k)
        while index < len(nums):

            # Current num
            num = nums[index]

            # Heap still has space, push num
            # k = 2, minHeap = [3], num = 2 -> [2, 3]
            # tc: O(log k)
            if len(minHeap) < k:
                heapq.heappush(minHeap, num)

            # Heap is full, only keep num if it beats the current kth largest
            else:

                # Replace root if num is larger:
                # k = 2, minHeap = [2, 3]
                #   num = 1 -> 1 < 2, ignored, heap stays [2, 3]
                #   num = 5 -> 5 > 2, replace root -> [3, 5]
                # tc: O(log k)
                if num > minHeap[0]:
                    heapq.heapreplace(minHeap, num)

            # Iterate array
            index += 1

        # Kth largest element (root)
        kthLargest = minHeap[0]

        # overall: tc O(n log k)
        # overall: sc O(k)
        return kthLargest

    def findKthLargest(self, nums: list[int], k: int) -> int:

        # Quick Select (Three Way Partition)

        # Search Representation:
        #   - nums is the current search space
        #   - k is the rank (1 = largest) of the target inside the current nums
        #   - Search space is valid while it still contains the kth largest

        # Idea:
        #   - Pick a random pivot and split nums into bigger, equal, and smaller
        #   - If k <= len(bigger), the kth largest is inside bigger, recurse there
        #   - If k <= len(bigger) + len(equal), the kth largest is the pivot itself,
        #     so every duplicate of the pivot is resolved in one step
        #   - Otherwise the kth largest is inside smaller, recurse there with
        #     k reduced by the number of elements ranked above it
        #   - Only one side is ever searched, so the work shrinks every call

        # Why Three Way (Duplicates):
        #   - A two way partition (<= pivot vs > pivot) leaves every copy of the pivot
        #     on one side, so with many duplicates the pivot barely shrinks the search space
        #   - Random pivots don't help, since every pivot has the same value
        #   - Each call then removes almost nothing, so time degrades to O(n^2) (TLE)
        #     and recursion depth can hit the limit
        #   - The equal bucket is never recursed into: if k lands inside it, the answer
        #     is the pivot, so all copies of that value cost one pass and then disappear
        #   - With no duplicates it costs nothing extra, still O(n) per pass

        # Helper that searches one partition for the kth largest
        def quickSelect(nums: list[int], k: int) -> int:

            # Random pivot
            pivot = random.choice(nums)

            # Partitions
            bigger = []
            equal = []
            smaller = []

            # Array Pointer
            index = 0

            # Partition nums around pivot
            # tc: O(n)
            while index < len(nums):

                # Current num
                num = nums[index]

                # Sort num into its partition
                if num > pivot:
                    bigger.append(num)
                elif num == pivot:
                    equal.append(num)
                else:
                    smaller.append(num)

                # Iterate array
                index += 1

            # Kth largest is inside bigger, recurse
            # nums = [3, 2, 1, 5, 6, 4], k = 2, pivot = 4
            # bigger = [5, 6], k <= 2 -> search [5, 6] for 2nd largest
            if k <= len(bigger):
                return quickSelect(bigger, k)

            # Kth largest is the pivot (duplicates resolved in one step):
            # bigger = [6], equal = [5], k = 2
            # k <= 1 + 1 -> the 2nd largest is 5
            if k <= len(bigger) + len(equal):
                return pivot

            # Kth largest is inside smaller, recurse with k adjusted:
            # nums = [3, 2, 1, 5, 6, 4], k = 5, pivot = 4
            # bigger = [5, 6], equal = [4], smaller = [3, 2, 1]
            # 5 > 2 + 1 -> search [3, 2, 1] for k = 5 - 2 - 1 = 2nd largest
            newK = k - len(bigger) - len(equal)
            return quickSelect(smaller, newK)

        # Kth largest element
        kthLargest = quickSelect(nums, k)

        # overall: tc O(n) average (n + n/2 + n/4 + ...), O(n^2) worst case with bad pivots
        # overall: sc O(n) for the partition lists, plus O(log n) expected recursion depth
        return kthLargest

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

class KthLargest:

    # MinHeap (Fixed Size K)

    # Heap Representation:
    #   - Maintain a minHeap holding the k largest elements seen so far
    #   - Root (minHeap[0]) is the smallest of those k elements,
    #     which is exactly the kth largest element overall
    #   - Heap is valid when it holds at most k elements

    # Idea:
    #   - The kth largest element is the smallest of the top k elements
    #   - Keep only the top k elements in a minHeap, so the root is always the answer
    #   - If the heap has fewer than k elements, push the new value
    #   - If the heap is full, the new value only matters if it beats the root,
    #     since anything smaller can never be in the top k
    #   - Replace the root with the new value to evict the old kth largest
    #   - Return the root after every add

    # KthLargest():
    #   - Initializes the minHeap
    #   - Streams nums into the heap one at a time through add

    # add():
    #   - Adds a number to the minHeap if it belongs in the top k
    #   - Returns the kth largest element so far

    def __init__(self, k: int, nums: list[int]):

        # Heap Size Limit
        self.k = k

        # MinHeap of the k largest elements seen so far
        self.minHeap = []

        # Stream Pointer
        index = 0

        # Mimic 'streaming' input data into minHeap
        # tc: O(n log k) - n calls to add, each O(log k)
        while index < len(nums):

            # Add num to heap
            self.add(nums[index])

            # Iterate stream
            index += 1

        # overall: tc O(n log k)
        # overall: sc O(k)

    def add(self, val: int) -> int:

        # Heap still has space, push new value
        # k = 3, minHeap = [4, 5], add(8) -> [4, 5, 8]
        # tc: O(log k)
        if len(self.minHeap) < self.k:
            heapq.heappush(self.minHeap, val)

        # Heap is full, only keep val if it beats the current kth largest
        else:

            # Current kth largest element
            kthLargest = self.minHeap[0]

            # Replace root if val is larger:
            # k = 3, minHeap = [4, 5, 8]
            #   add(3)  -> 3 < 4, ignored, heap stays [4, 5, 8]
            #   add(10) -> 10 > 4, replace root -> [5, 8, 10]
            # tc: O(log k)
            if val > kthLargest:
                heapq.heapreplace(self.minHeap, val)

        # Return kth largest element (root), tc: O(1)

        # overall: tc O(log k)
        # overall: sc O(1) extra, O(k) for the heap itself
        return self.minHeap[0]

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

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

        # Lazy Subtraction:
        # Sort so values are processed in increasing order, then simulate
        # each operation's effect without touching every array slot on
        # every operation. Instead, track a running "alreadySubtracted"
        # total; each element's TRUE current value is (original value -
        # alreadySubtracted), which is exactly what repeatedly
        # subtracting x from every positive element produces in aggregate.

        # nums_sorted = [0, 1, 3, 5, 5]
        # alreadySubtracted starts at 0, grows by each new tier's value
        # as we sweep left to right

        # sc: O(n), space used by sorted() to produce nums_sorted
        numsSorted = sorted(nums)

        n = len(numsSorted)

        # Running count of total amount subtracted by completed operations
        alreadySubtracted = 0

        operationsCount = 0

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

            # Note:
            # TRUE current value after all prior operations have been
            # applied -- the real result of every earlier subtraction,
            # computed lazily instead of mutating the whole array.
            currentValue = numsSorted[i] - alreadySubtracted

            # skip: already at zero (started at 0, or zeroed by a
            # previous operation)
            if currentValue <= 0:
                continue

            # New operation:
            # new distinct positive value not yet zeroed. Perform one
            # operation: x = currentValue (guaranteed smallest
            # remaining nonzero value, since array is sorted).
            # tc: O(1) per operation
            alreadySubtracted += currentValue
            operationsCount += 1

        # overall: tc O(n log n)
        # overall: sc O(n)
        return operationsCount

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

        # MinHeap:
        # A min-heap always pops the current smallest remaining value in
        # O(log n), without needing a full sort upfront. Same lazy
        # subtraction idea as the sorting solution -- a running
        # "alreadySubtracted" total is applied only when a value is
        # popped, rather than mutating every array slot on every
        # operation. This simulates the same tier-by-tier subtraction
        # process, just driven by heap pops instead of a sorted pass.

        # heap = [0, 1, 3, 5, 5] (heap-ordered, not necessarily sorted)
        # each pop returns the current global minimum remaining value

        # heap holds all elements initially
        # sc: O(n)
        heap = list(nums)

        # heapify in linear time
        # tc: O(n)
        heapq.heapify(heap)

        # Running count of total amount subtracted by completed operations
        alreadySubtracted = 0

        operationsCount = 0

        # tc: O(n) pops each O(log n) for total O(n log n)
        while heap:

            # Pop the current smallest remaining value
            # tc: O(log n) per pop
            smallest = heapq.heappop(heap)

            # Note:
            # TRUE current value after all prior operations have been
            # applied -- same lazy-subtraction idea as the sorting
            # solution, just computed at pop time instead of during a
            # linear pass over a sorted array.
            currentValue = smallest - alreadySubtracted

            # skip: already at zero (started at 0, or zeroed by a
            # previous operation)
            if currentValue <= 0:
                continue

            # New operation:
            # new distinct positive value not yet zeroed. Perform one
            # operation: x = currentValue (guaranteed smallest
            # remaining nonzero value, since heap always pops the min).
            alreadySubtracted += currentValue
            operationsCount += 1

        # overall: tc O(n log n)
        # overall: sc O(n)
        return operationsCount

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

        # Distinct Count:
        # Every operation subtracts the same x from ALL positive elements
        # at once. This means elements sharing the same value always hit
        # zero together, in the same single operation -- duplicates of a
        # value never require extra operations. Also, x is capped at the
        # current smallest nonzero value, so an operation can never skip
        # past a distinct value to clear two tiers at once. The answer
        # reduces to: how many DISTINCT positive values exist in nums.

        # nums = [1, 5, 0, 3, 5]
        # distinct positive values -> {1, 3, 5}
        # each distinct value needs exactly 1 dedicated operation,
        # duplicates (the two 5's) ride along for free

        # sc: O(n) worst case, one entry per distinct positive value
        distinct_positive = set()

        # tc: O(n), one pass over nums
        for num in nums:

            # skip zeros: already at the target, no operation needed
            if num > 0:
                distinct_positive.add(num)

        operationsCount = len(distinct_positive)

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

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

    def topKFrequent(self, nums: list[int], k: int) -> list[int]:

        # MinHeap (Fixed Size K)

        # Heap Representation:
        #   - Maintain a minHeap of (frequency, num) pairs for the k most frequent elements so far
        #   - Root (minHeap[0]) is the least frequent of those k elements,
        #     which is the first one to evict
        #   - Heap is valid when it holds at most k pairs

        # Idea:
        #   - Count the frequency of each element
        #   - Push each unique (frequency, num) pair into the minHeap
        #   - If the heap grows to size k + 1, pop the root, since the least frequent
        #     of k + 1 elements can never be in the top k
        #   - A heap only guarantees the root is the smallest, not the order of the rest,
        #     which is fine because the answer can be returned in any order
        #   - After every unique element has been seen, the heap holds the k most frequent

        # Frequency of each element
        frequency = defaultdict(int)

        # Array Pointer
        index = 0

        # Count each num
        # tc: O(n)
        while index < len(nums):

            # Add num to count
            frequency[nums[index]] += 1

            # Iterate array
            index += 1

        # MinHeap of (frequency, num) pairs for the k most frequent elements
        minHeap = []

        # Unique (num, count) pairs
        uniqueItems = list(frequency.items())

        # Unique Pointer
        uniqueIndex = 0

        # tc: O(m log k), m unique elements, each push and pop is O(log k)
        while uniqueIndex < len(uniqueItems):

            # Current pair
            num, count = uniqueItems[uniqueIndex]

            # Push pair
            # k = 2, minHeap = [(1, 5), (2, 7)], pair = (3, 9) -> [(1, 5), (2, 7), (3, 9)]
            # tc: O(log k)
            heapq.heappush(minHeap, (count, num))

            # Heap exceeds k, pop the least frequent root
            # [(1, 5), (2, 7), (3, 9)] -> pop (1, 5) -> [(2, 7), (3, 9)]
            # tc: O(log k)
            if len(minHeap) > k:
                heapq.heappop(minHeap)

            # Iterate unique pairs
            uniqueIndex += 1

        # Top k elements
        result = []

        # Heap Pointer
        heapIndex = 0

        # Collect nums from the heap
        # tc: O(k)
        while heapIndex < len(minHeap):

            # Add num (second item of the pair)
            result.append(minHeap[heapIndex][1])

            # Iterate heap
            heapIndex += 1

        # overall: tc O(n + m log k), worst case m = n so O(n log k)
        # overall: sc O(n) for the frequency map, O(k) for the heap
        return result

    def topKFrequent(self, nums: list[int], k: int) -> list[int]:

        # Quick Select (Partition By Frequency, High To Low)

        # Search Representation:
        #   - unique is the list of unique elements, partitioned in place
        #   - [left, right] is the current search section of unique
        #   - targetIndex = k - 1 is the final position we need to place correctly
        #   - Search section is valid while it still contains targetIndex

        # Idea:
        #   - Count the frequency of each element, then work only on the unique elements
        #   - Pick a random pivot and partition the section so more frequent elements
        #     sit on the left and less frequent elements sit on the right:
        #     [more frequent ... pivot ... less frequent]
        #   - If the pivot lands at targetIndex, everything to its left is more frequent,
        #     so unique[:k] is the top k
        #   - If targetIndex is left of the pivot, search the left section
        #   - If targetIndex is right of the pivot, search the right section
        #   - Only one side is ever searched, so we never sort the whole array
        #   - A random pivot avoids the O(n^2) worst case of a fixed pivot

        # Frequency of each element
        frequency = defaultdict(int)

        # Array Pointer
        index = 0

        # Count each num
        # tc: O(n)
        while index < len(nums):

            # Add num to count
            frequency[nums[index]] += 1

            # Iterate array
            index += 1

        # Unique elements to partition by frequency
        unique = list(frequency.keys())

        # Helper that partitions [left, right] around the pivot, returns the pivot's final index
        def partitionSection(left: int, right: int, pivotIndex: int) -> int:

            # Frequency of pivot element
            pivotFrequency = frequency[unique[pivotIndex]]

            # Move pivot to the end
            unique[pivotIndex], unique[right] = unique[right], unique[pivotIndex]

            # Next slot for a more frequent element
            partitionIndex = left

            # Scan Pointer
            scanIndex = left

            # Partition section around pivot
            # tc: O(m) for a section of m elements
            while scanIndex < right:

                # Move more frequent elements to the left:
                # unique = [4, 1, 2] with frequency 4 -> 1, 1 -> 3, 2 -> 2, pivot = 2 (at right)
                #   scan 4 -> frequency 1 < 2, stays
                #   scan 1 -> frequency 3 > 2, swap with partitionIndex 0 -> [1, 4, 2], partitionIndex = 1
                if frequency[unique[scanIndex]] > pivotFrequency:
                    unique[scanIndex], unique[partitionIndex] = unique[partitionIndex], unique[scanIndex]
                    partitionIndex += 1

                # Iterate section
                scanIndex += 1

            # Place pivot at its final index:
            # [1, 4, 2] -> swap partitionIndex 1 with right -> [1, 2, 4], pivot lands at 1
            unique[partitionIndex], unique[right] = unique[right], unique[partitionIndex]
            return partitionIndex

        # Helper that narrows [left, right] until targetIndex holds its final element
        def quickSelect(left: int, right: int, targetIndex: int) -> None:

            # One element left, it is already in place
            if left == right:
                return

            # Random pivot
            pivotIndex = random.randint(left, right)

            # Partition section
            resultIndex = partitionSection(left, right, pivotIndex)

            # Pivot landed on target, unique[:k] is the top k
            if targetIndex == resultIndex:
                return

            # Target is left of the pivot, search the left section
            # k = 2 -> targetIndex = 1, resultIndex = 3 -> search [left, 2]
            elif targetIndex < resultIndex:
                quickSelect(left, resultIndex - 1, targetIndex)

            # Target is right of the pivot, search the right section
            # k = 4 -> targetIndex = 3, resultIndex = 1 -> search [2, right]
            else:
                quickSelect(resultIndex + 1, right, targetIndex)

        # Final index of the kth most frequent element
        # k = 2 -> top 2 are indexes [0, 1], so targetIndex = 1
        targetIndex = k - 1

        # Place targetIndex, everything left of it is at least as frequent
        # tc: O(m) average, O(m^2) worst case with bad pivots
        quickSelect(0, len(unique) - 1, targetIndex)

        # overall: tc O(n) average, n for counting + m for quick select, O(n + m^2) worst case
        # overall: sc O(n) for the frequency map and unique list, plus O(log m) expected recursion depth
        return unique[:k]

    def topKFrequent(self, nums: list[int], k: int) -> list[int]:

        # Bucket Sort (Index = Frequency)

        # Bucket Representation:
        #   - freqBuckets[count] holds every element that occurs exactly count times
        #   - Buckets run from index 0 to n, since an element can occur at most n times
        #   - Higher index = more frequent, so walking from the end visits the top elements first

        # Idea:
        #   - Count the frequency of each element
        #   - Drop each unique element into the bucket for its frequency
        #   - Walk the buckets from highest to lowest, collecting elements
        #   - Stop as soon as k elements are collected
        #   - No comparison sort is needed, since the frequency itself is the bucket index

        # Frequency of each element
        frequency = defaultdict(int)

        # Array Pointer
        index = 0

        # Count each num
        # tc: O(n)
        while index < len(nums):

            # Add num to count
            frequency[nums[index]] += 1

            # Iterate array
            index += 1

        # Number of buckets, +1 so index n exists (one element repeated n times)
        # nums length 5 -> buckets [0, 1, 2, 3, 4, 5], index 0 stays empty
        numBuckets = len(nums) + 1

        # Empty bucket for every possible frequency
        freqBuckets = []

        # Bucket Pointer
        bucketIndex = 0

        # Create buckets
        # tc: O(n)
        while bucketIndex < numBuckets:

            # Add empty bucket
            freqBuckets.append([])

            # Iterate buckets
            bucketIndex += 1

        # Unique (num, count) pairs
        uniqueItems = list(frequency.items())

        # Unique Pointer
        uniqueIndex = 0

        # Place each unique num into its frequency bucket
        # nums = [1, 1, 1, 2, 2, 3] -> freqBuckets = [[], [3], [2], [1], [], [], []]
        # tc: O(m)
        while uniqueIndex < len(uniqueItems):

            # Current pair
            num, count = uniqueItems[uniqueIndex]

            # Add num to its frequency bucket
            freqBuckets[count].append(num)

            # Iterate unique pairs
            uniqueIndex += 1

        # Top k elements
        result = []

        # Bucket Pointer (highest frequency first, index 0 is always empty)
        bucketIndex = len(freqBuckets) - 1

        # Walk buckets from high to low until k elements are collected
        # k = 2 -> bucket 3 adds [1], bucket 2 adds [2], result = [1, 2], loop stops
        # tc: O(n) buckets, O(m) elements across all buckets
        while bucketIndex > 0 and len(result) < k:

            # Bucket Element Pointer
            bucketItemIndex = 0

            # Collect elements from the current bucket
            while bucketItemIndex < len(freqBuckets[bucketIndex]) and len(result) < k:

                # Add num to result
                result.append(freqBuckets[bucketIndex][bucketItemIndex])

                # Iterate bucket
                bucketItemIndex += 1

            # Iterate buckets (toward lower frequency)
            bucketIndex -= 1

        # overall: tc O(n)
        # overall: sc O(n) for the frequency map and buckets
        return result

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

    def kClosest(self, points: list[list[int]], k: int) -> list[list[int]]:

        # MaxHeap (Fixed Size K)

        # Heap Representation:
        #   - Maintain a maxHeap of (-squaredDistance, point) for the k closest points seen so far
        #   - heapq is a minHeap, so distances are negated to make the largest distance the root
        #   - Root (maxHeap[0]) is the farthest of those k points,
        #     which is the first one to evict
        #   - Heap is valid when it holds at most k points

        # Idea:
        #   - sqrt is monotonic, so comparing x * x + y * y orders points the same
        #     as comparing true distances, and avoids floats
        #   - The k closest points are the k smallest distances, so keep only those k
        #     in a maxHeap, where the root is the farthest of the k
        #   - If the heap has fewer than k points, push the new point
        #   - If the heap is full, the new point only matters if it is closer than the root,
        #     since anything farther can never be in the top k
        #   - Replace the root with the new point to evict the old farthest
        #   - After every point has been seen, the heap holds the k closest, in any order

        # MaxHeap of (-squaredDistance, point) for the k closest points
        maxHeap = []

        # Array Pointer
        index = 0

        # tc: O(n log k)
        while index < len(points):

            # Current point and its squared distance
            x, y = points[index]
            squaredDistance = x * x + y * y

            # Heap still has space, push point
            # k = 2, maxHeap = [(-18, [3, 3])], point = [5, -1] -> [(-26, [5, -1]), (-18, [3, 3])]
            # tc: O(log k)
            if len(maxHeap) < k:
                heapq.heappush(maxHeap, (-squaredDistance, [x, y]))

            # Heap is full, only keep point if it is closer than the current farthest
            else:

                # Replace root if point is closer:
                # k = 2, maxHeap = [(-26, [5, -1]), (-18, [3, 3])]
                #   point = [-2, 4] -> 20 < 26, replace root -> [(-20, [-2, 4]), (-18, [3, 3])]
                #   a point with distance 30 -> 30 > 20, ignored, heap stays the same
                # tc: O(log k)
                if squaredDistance < -maxHeap[0][0]:
                    heapq.heapreplace(maxHeap, (-squaredDistance, [x, y]))

            # Iterate array
            index += 1

        # K closest points
        result = []

        # Heap Pointer
        heapIndex = 0

        # Collect points from the heap
        # tc: O(k)
        while heapIndex < len(maxHeap):

            # Add point (second item of the pair)
            result.append(maxHeap[heapIndex][1])

            # Iterate heap
            heapIndex += 1

        # overall: tc O(n log k)
        # overall: sc O(k) for the heap
        return result

    def kClosest(self, points: list[list[int]], k: int) -> list[list[int]]:

        # Quick Select (Partition By Squared Distance, Closest To Farthest)

        # Search Representation:
        #   - points is partitioned in place
        #   - [left, right] is the current search section of points
        #   - targetIndex = k - 1 is the final position we need to place correctly
        #   - Search section is valid while it still contains targetIndex

        # Idea:
        #   - sqrt is monotonic, so partition by x * x + y * y instead of true distance
        #   - Pick a random pivot and partition the section so closer points
        #     sit on the left and farther points sit on the right:
        #     [closer ... pivot ... farther]
        #   - If the pivot lands at targetIndex, everything to its left is closer,
        #     so points[:k] is the k closest
        #   - If targetIndex is left of the pivot, search the left section
        #   - If targetIndex is right of the pivot, search the right section
        #   - Only one side is ever searched, so we never sort the whole array
        #   - A random pivot avoids the O(n^2) worst case of a fixed pivot

        # Helper that returns the squared distance of the point at index
        def squaredDistance(index: int) -> int:
            return points[index][0] ** 2 + points[index][1] ** 2

        # Helper that partitions [left, right] around the pivot, returns the pivot's final index
        def partitionSection(left: int, right: int, pivotIndex: int) -> int:

            # Squared distance of pivot
            pivotDistance = squaredDistance(pivotIndex)

            # Move pivot to the end
            points[pivotIndex], points[right] = points[right], points[pivotIndex]

            # Next slot for a closer point
            partitionIndex = left

            # Scan Pointer
            scanIndex = left

            # Partition section around pivot
            # tc: O(m) for a section of m points
            while scanIndex < right:

                # Move closer points to the left:
                # points = [[3, 3], [5, -1], [-2, 4]] with distances 18, 26, 20, pivot = [-2, 4] (at right)
                #   scan [3, 3]  -> 18 < 20, swap with partitionIndex 0 (itself), partitionIndex = 1
                #   scan [5, -1] -> 26 > 20, stays
                if squaredDistance(scanIndex) < pivotDistance:
                    points[scanIndex], points[partitionIndex] = points[partitionIndex], points[scanIndex]
                    partitionIndex += 1

                # Iterate section
                scanIndex += 1

            # Place pivot at its final index:
            # [[3, 3], [5, -1], [-2, 4]] -> swap partitionIndex 1 with right -> [[3, 3], [-2, 4], [5, -1]], pivot lands at 1
            points[partitionIndex], points[right] = points[right], points[partitionIndex]
            return partitionIndex

        # Helper that narrows [left, right] until targetIndex holds its final point
        def quickSelect(left: int, right: int, targetIndex: int) -> None:

            # One point left, it is already in place
            if left >= right:
                return

            # Random pivot
            pivotIndex = random.randint(left, right)

            # Partition section
            resultIndex = partitionSection(left, right, pivotIndex)

            # Pivot landed on target, points[:k] is the k closest
            if targetIndex == resultIndex:
                return

            # Target is left of the pivot, search the left section
            # k = 1 -> targetIndex = 0, resultIndex = 2 -> search [left, 1]
            elif targetIndex < resultIndex:
                quickSelect(left, resultIndex - 1, targetIndex)

            # Target is right of the pivot, search the right section
            # k = 3 -> targetIndex = 2, resultIndex = 1 -> search [2, right]
            else:
                quickSelect(resultIndex + 1, right, targetIndex)

        # Final index of the kth closest point
        # k = 2 -> k closest are indexes [0, 1], so targetIndex = 1
        targetIndex = k - 1

        # Place targetIndex, everything left of it is at least as close
        # tc: O(n) average, O(n^2) worst case with bad pivots
        quickSelect(0, len(points) - 1, targetIndex)

        # K closest points
        # tc: O(k)
        closest = points[:k]

        # overall: tc O(n) average, O(n^2) worst case with bad pivots
        # overall: sc O(k) for the returned list, plus O(log n) expected recursion depth
        return closest

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

    def kthLargestNumber(self, nums: list[str], k: int) -> str:

        # MinHeap (Fixed Size K)

        # Heap Representation:
        #   - Maintain a minHeap holding the keys of the k largest numbers seen so far
        #   - Each key is (length, string), which sorts in true numeric order
        #   - Root (minHeap[0]) is the smallest of those k keys,
        #     which is exactly the kth largest number overall
        #   - Heap is valid when it holds at most k keys

        # Idea:
        #   - nums are strings of huge integers, so raw string comparison is wrong ("10" < "9")
        #   - A longer string is always the bigger number (no leading zeros),
        #     and equal length strings compare correctly lexicographically,
        #     so the key (length, string) orders them numerically
        #   - The kth largest is the smallest of the top k, so keep only the top k keys in a minHeap
        #   - If the heap has fewer than k keys, push the new key
        #   - If the heap is full, the new key only matters if it beats the root,
        #     since anything smaller can never be in the top k
        #   - Replace the root with the new key to evict the old kth largest
        #   - After every string has been seen, the root's string is the answer

        # Helper that builds a numerically ordered key
        def numKey(numStr: str) -> tuple[int, str]:
            return (len(numStr), numStr)

        # MinHeap of the keys of the k largest numbers seen so far
        minHeap = []

        # Array Pointer
        index = 0

        # tc: O(n log k * d), n calls with an O(log k) heap op, each comparing keys up to d digits
        while index < len(nums):

            # Current key
            key = numKey(nums[index])

            # Heap still has space, push key
            # k = 2, minHeap = [(1, "3")], key = (2, "10") -> [(1, "3"), (2, "10")]
            # tc: O(log k * d)
            if len(minHeap) < k:
                heapq.heappush(minHeap, key)

            # Heap is full, only keep key if it beats the current kth largest
            else:

                # Replace root if key is larger:
                # k = 2, minHeap = [(1, "3"), (2, "10")]
                #   "2" -> (1, "2") < (1, "3"), ignored, heap stays the same
                #   "6" -> (1, "6") > (1, "3"), replace root -> [(1, "6"), (2, "10")]
                # tc: O(log k * d)
                if key > minHeap[0]:
                    heapq.heapreplace(minHeap, key)

            # Iterate array
            index += 1

        # Kth largest number (string stored in the root key)
        kthLargest = minHeap[0][1]

        # overall: tc O(n log k * d), d = max digits in a string
        # overall: sc O(k * d), for the heap keys
        return kthLargest

    def kthLargestNumber(self, nums: list[str], k: int) -> str:

        # Quick Select (Three Way Partition)

        # Search Representation:
        #   - nums is the current search space
        #   - k is the rank (1 = largest) of the target inside the current nums
        #   - Search space is valid while it still contains the kth largest

        # Idea:
        #   - nums are strings of huge integers, so compare by key (length, string)
        #     instead of raw string order, which avoids int() conversion on 100 digit strings
        #   - Pick a random pivot and split nums into bigger, equal, and smaller by key
        #   - If k <= len(bigger), the kth largest is inside bigger, recurse there
        #   - If k <= len(bigger) + len(equal), the kth largest is the pivot itself,
        #     so every duplicate of the pivot is resolved in one step
        #   - Otherwise the kth largest is inside smaller, recurse there with
        #     k reduced by the number of elements ranked above it
        #   - Only one side is ever searched, so the work shrinks every call

        # Why Three Way (Duplicates):
        #   - A two way partition (<= pivot vs > pivot) leaves every copy of the pivot
        #     on one side, so with many duplicates the pivot barely shrinks the search space
        #   - Random pivots don't help, since every pivot has the same value
        #   - Each call then removes almost nothing, so time degrades to O(n^2) (TLE)
        #     and recursion depth can hit the limit
        #   - The equal bucket is never recursed into: if k lands inside it, the answer
        #     is the pivot, so all copies of that value cost one pass and then disappear
        #   - With no duplicates it costs nothing extra, still O(n) per pass

        # Helper that builds a numerically ordered key
        def numKey(numStr: str) -> tuple[int, str]:
            return (len(numStr), numStr)

        # Helper that searches one partition for the kth largest
        def quickSelect(nums: list[str], k: int) -> str:

            # Random pivot
            pivot = random.choice(nums)
            pivotKey = numKey(pivot)

            # Partitions
            bigger = []
            equal = []
            smaller = []

            # Array Pointer
            index = 0

            # Partition nums around pivot
            # tc: O(n * d)
            while index < len(nums):

                # Current num and key
                num = nums[index]
                key = numKey(num)

                # Sort num into its partition
                if key > pivotKey:
                    bigger.append(num)
                elif key == pivotKey:
                    equal.append(num)
                else:
                    smaller.append(num)

                # Iterate array
                index += 1

            # Kth largest is inside bigger, recurse
            # nums = ["3", "6", "7", "10"], k = 2, pivot = "6"
            # bigger = ["7", "10"], k <= 2 -> search ["7", "10"] for 2nd largest
            if k <= len(bigger):
                return quickSelect(bigger, k)

            # Kth largest is the pivot (duplicates resolved in one step):
            # nums = ["3", "6", "7", "10"], k = 3, pivot = "6"
            # bigger = ["7", "10"], equal = ["6"]
            # k <= 2 + 1 -> the 3rd largest is "6"
            if k <= len(bigger) + len(equal):
                return pivot

            # Kth largest is inside smaller, recurse with k adjusted:
            # nums = ["3", "6", "7", "10"], k = 4, pivot = "6"
            # bigger = ["7", "10"], equal = ["6"], smaller = ["3"]
            # 4 > 2 + 1 -> search ["3"] for k = 4 - 2 - 1 = 1st largest
            newK = k - len(bigger) - len(equal)
            return quickSelect(smaller, newK)

        # Kth largest number
        kthLargest = quickSelect(nums, k)

        # overall: tc O(n * d) average (n + n/2 + n/4 + ...), O(n^2 * d) worst case with bad pivots
        # overall: sc O(n) for the partition lists, plus O(log n) expected recursion depth
        return kthLargest

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

    def mergeKLists(self, lists: list[Optional[ListNode]]) -> Optional[ListNode]:

        # MinHeap (K Way Merge)

        # Heap Representation:
        #   - Maintain a minHeap of (value, listIndex, node) candidates, one per non empty list
        #   - Each list is sorted, so a list's candidate is its smallest node not yet taken
        #   - Root (minHeap[0]) is the smallest value among all candidates not yet taken
        #   - Heap is valid when it holds at most one candidate per list

        # Idea:
        #   - Every list is sorted, so the next node of the merged list is always
        #     the smallest of the k current heads
        #   - Seed the heap with the head of every non empty list
        #   - Pop the root, attach it to the merged list, then push the next node
        #     in the same list, so each list always has exactly one candidate in the heap
        #   - A list's 2nd node can't matter before its 1st is popped,
        #     so the heap holds at most k nodes instead of all N
        #   - listIndex is the tiebreaker: when two values are equal, heapq would compare
        #     the ListNode objects next, which raises a TypeError, so the unique index
        #     decides before it ever gets that far
        #   - Stop when the heap is empty, every list has been fully merged

        # MinHeap of (value, listIndex, node) candidates, one per non empty list
        minHeap = []

        # List Pointer
        seedIndex = 0

        # Seed each non empty list with its head
        # tc: O(k)
        while seedIndex < len(lists):

            # Add head of the list, skipping empty lists
            if lists[seedIndex]:
                minHeap.append((lists[seedIndex].val, seedIndex, lists[seedIndex]))

            # Iterate lists
            seedIndex += 1

        # Order the seeds into a heap
        # tc: O(k)
        heapq.heapify(minHeap)

        # Dummy head so the first attach needs no special case
        dummyHead = ListNode(-1)

        # End of the merged list
        tail = dummyHead

        # tc: O(N log k), N pops, each heap op is O(log k)
        while minHeap:

            # Smallest candidate
            value, listIndex, node = heapq.heappop(minHeap)

            # Attach node to merged list
            tail.next = node
            tail = tail.next

            # List has a next node, push it:
            # lists = [[1, 4, 5], [1, 3, 4], [2, 6]]
            #   seeds -> [(1, 0, 1), (1, 1, 1), (2, 2, 2)]
            #   pop (1, 0, 1) -> merged [1], push (4, 0, 4)
            #   pop (1, 1, 1) -> merged [1, 1], push (3, 1, 3)
            #   pop (2, 2, 2) -> merged [1, 1, 2], push (6, 2, 6)
            #   ... until the heap is empty -> [1, 1, 2, 3, 4, 4, 5, 6]
            # tc: O(log k)
            if node.next:
                heapq.heappush(minHeap, (node.next.val, listIndex, node.next))

        # Merged list (after the dummy)
        mergedHead = dummyHead.next

        # overall: tc O(N log k), N = total nodes, k = number of lists
        # overall: sc O(k) for the heap, nodes are relinked in place
        return mergedHead

    def mergeKLists(self, lists: list[Optional[ListNode]]) -> Optional[ListNode]:

        # Divide And Conquer (Pairwise Merge)

        # Merge Representation:
        #   - lists holds the sorted lists still to be merged
        #   - Each round merges lists[0] with lists[1], lists[2] with lists[3], and so on
        #   - Merge is done when lists holds exactly one list

        # Idea:
        #   - Merging two sorted lists is a simple two pointer walk, O(length of both)
        #   - Merge the k lists in pairs, so each round halves the number of lists,
        #     which takes O(log k) rounds
        #   - Every round touches each node once across all of its merges, O(N) per round
        #   - An odd list out is merged with None, which just carries it to the next round
        #   - Merging one list at a time into a growing result is O(N * k),
        #     because the early nodes get re walked every merge, pairing keeps the lists balanced

        # Empty check, k can be 0
        if not lists:
            return None

        # Helper that merges two sorted lists
        def mergeTwo(first: Optional[ListNode], second: Optional[ListNode]) -> Optional[ListNode]:

            # Dummy head so the first attach needs no special case
            dummyHead = ListNode(-1)

            # End of the merged list
            tail = dummyHead

            # Merge while both lists have nodes
            # first = [1, 4], second = [2, 3]
            #   1 < 2 -> attach 1, then 2 <= 4 -> attach 2, then 3 < 4 -> attach 3
            #   second is empty, attach the rest of first -> [1, 2, 3, 4]
            # tc: O(length of both lists)
            while first and second:

                # Attach the smaller node
                if first.val < second.val:
                    tail.next = first
                    first = first.next
                else:
                    tail.next = second
                    second = second.next

                # Iterate merged list
                tail = tail.next

            # Attach the remaining list, at most one is non empty
            if first:
                tail.next = first
            else:
                tail.next = second

            return dummyHead.next

        # tc: O(log k) rounds, each round is O(N)
        while len(lists) > 1:

            # Lists produced by this round
            merged = []

            # Pair Pointer
            pairIndex = 0

            # Merge lists in pairs
            # lists = [A, B, C] -> [merge(A, B), merge(C, None)] -> [merge(merge(A, B), C)]
            # tc: O(N)
            while pairIndex < len(lists):

                # Pair of lists, second is None for an odd list out
                first = lists[pairIndex]
                second = lists[pairIndex + 1] if pairIndex + 1 < len(lists) else None

                # Add merged pair
                merged.append(mergeTwo(first, second))

                # Iterate pairs
                pairIndex += 2

            # Next round works on the merged lists
            lists = merged

        # overall: tc O(N log k), N = total nodes, k = number of lists
        # overall: sc O(k) for the merged list of heads each round, nodes are relinked in place
        return lists[0]

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

    def kSmallestPairs(self, nums1: list[int], nums2: list[int], k: int) -> list[list[int]]:

        # MinHeap (K Way Merge)

        # Heap Representation:
        #   - Maintain a minHeap of (sum, i, j) candidates, one per row i of nums1
        #   - Row i is the sorted list nums1[i] + nums2[0], nums1[i] + nums2[1], ...
        #   - Root (minHeap[0]) is the smallest sum among all candidates not yet taken
        #   - Heap is valid when it holds at most one candidate per row

        # Idea:
        #   - nums2 is sorted, so for a fixed i the sums grow as j grows,
        #     which makes every row its own sorted list
        #   - Finding the k smallest across these lists is the same k way merge as
        #     Merge K Sorted Lists and Kth Smallest In A Sorted Matrix
        #   - Pop the root, add its pair to the result, then push the next pair in the same row
        #     (i, j + 1), so each row always has exactly one candidate in the heap
        #   - Only seed min(n1, k) rows: pair (i, 0) is never smaller than pairs (0..i-1, 0),
        #     so a row at index k or beyond can't reach the first k results
        #   - Seeding fewer rows keeps the heap size, and each heap op, bounded by min(n1, k)
        #   - Stop once k pairs are collected

        # Lengths
        n1 = len(nums1)
        n2 = len(nums2)

        # Rows to seed
        seedCount = min(n1, k)

        # MinHeap of (sum, i, j) candidates, one per seeded row
        minHeap = []

        # Row Pointer
        row = 0

        # Seed each row with nums2[0], the smallest partner for that row
        # tc: O(min(n1, k))
        while row < seedCount:

            # Add first candidate of the row
            minHeap.append((nums1[row] + nums2[0], row, 0))

            # Iterate rows
            row += 1

        # Order the seeds into a heap
        # tc: O(min(n1, k))
        heapq.heapify(minHeap)

        # K smallest pairs
        result = []

        # tc: O(k log min(n1, k)), k pops, each heap op is O(log min(n1, k))
        while minHeap and len(result) < k:

            # Smallest candidate
            total, i, j = heapq.heappop(minHeap)

            # Add pair to result
            result.append([nums1[i], nums2[j]])

            # Row has a next candidate, push it:
            # nums1 = [1, 7, 11], nums2 = [2, 4, 6], k = 3
            #   seeds -> [(3, 0, 0), (9, 1, 0), (13, 2, 0)]
            #   pop (3, 0, 0) -> [1, 2], push (5, 0, 1)
            #   pop (5, 0, 1) -> [1, 4], push (7, 0, 2)
            #   pop (7, 0, 2) -> [1, 6], j + 1 = 3 is out of range, nothing to push
            # tc: O(log min(n1, k))
            if j + 1 < n2:
                heapq.heappush(minHeap, (nums1[i] + nums2[j + 1], i, j + 1))

        # overall: tc O(k log min(n1, k))
        # overall: sc O(min(n1, k)) for the heap, O(k) for the result
        return result

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

    def kthSmallest(self, matrix: list[list[int]], k: int) -> int:

        # MinHeap (K Way Merge)

        # Heap Representation:
        #   - Maintain a minHeap of (value, row, col) candidates, one per row
        #   - Each row is already a sorted list, so a row's candidate is its smallest element not yet taken
        #   - Root (minHeap[0]) is the smallest value among all candidates not yet taken
        #   - Heap is valid when it holds at most one candidate per row

        # Idea:
        #   - Every row is sorted, so the matrix is n separate sorted lists
        #   - Finding the kth smallest across sorted lists is the same k way merge as
        #     Merge K Sorted Lists
        #   - Seed every row with its first (smallest) element
        #   - Pop the root k - 1 times to discard the k - 1 smallest values,
        #     and after each pop push the next element in the same row (row, col + 1),
        #     so each row always has exactly one candidate in the heap
        #   - A row's 2nd element can't matter before its 1st is popped,
        #     so the heap holds at most n entries instead of n^2
        #   - After the k - 1 pops, the root is the kth smallest

        # Number of rows
        n = len(matrix)

        # MinHeap of (value, row, col) candidates, one per row
        minHeap = []

        # Row Pointer
        row = 0

        # Seed each row with its first element
        # tc: O(n)
        while row < n:

            # Add first candidate of the row
            minHeap.append((matrix[row][0], row, 0))

            # Iterate rows
            row += 1

        # Order the seeds into a heap
        # tc: O(n)
        heapq.heapify(minHeap)

        # Discarded Pops
        popCount = 0

        # Discard the k - 1 smallest values
        # tc: O(k log n), k - 1 pops and pushes, each heap op is O(log n)
        while popCount < k - 1:

            # Smallest candidate
            value, row, col = heapq.heappop(minHeap)

            # Row has a next candidate, push it:
            # matrix = [[1, 5, 9], [10, 11, 13], [12, 13, 15]], k = 8
            #   seeds -> [(1, 0, 0), (10, 1, 0), (12, 2, 0)]
            #   pop (1, 0, 0), col + 1 = 1 < 3 -> push (5, 0, 1)
            #   pop (5, 0, 1), col + 1 = 2 < 3 -> push (9, 0, 2)
            #   pop (9, 0, 2), col + 1 = 3 is out of range, nothing to push
            #   ... after 7 pops the root is the second 13, the 8th smallest
            # tc: O(log n)
            if col + 1 < n:
                heapq.heappush(minHeap, (matrix[row][col + 1], row, col + 1))

            # Iterate pops
            popCount += 1

        # Kth smallest value (root)
        kthSmallest = minHeap[0][0]

        # overall: tc O(n + k log n), seeding with heapify is O(n), k - 1 pops and pushes are O(k log n)
        # overall: sc O(n) for the heap
        return kthSmallest

    def kthSmallest(self, matrix: list[list[int]], k: int) -> int:

        # Binary Search (On Value)

        # Search Representation:
        #   - [low, high] is the range of possible values for the answer
        #   - Starts as [matrix[0][0], matrix[n - 1][n - 1]], the smallest and largest values
        #   - Search is done when low == high, one candidate value remains

        # Idea:
        #   - We don't binary search positions, we binary search over VALUES
        #   - For a candidate value x, count how many elements are <= x
        #   - If the count is >= k, the kth smallest is at most x, so high = mid
        #   - Otherwise the kth smallest is greater than x, so low = mid + 1
        #   - The range collapses onto the smallest value whose count is >= k,
        #     and that value is guaranteed to be inside the matrix

        # Staircase Count (Saddleback Search):
        #   - Start at the bottom left corner
        #   - If the element is <= x, every element above it in that column is also <= x,
        #     so count the whole column at once and move right
        #   - If the element is > x, every element to its right in that row is also > x,
        #     so move up
        #   - Each step moves right or up, so at most 2n steps, O(n) per count

        # Number of rows and columns
        n = len(matrix)

        # Helper that counts elements <= x
        def countLessEqual(x: int) -> int:

            # Elements <= x
            count = 0

            # Staircase Pointers (bottom left)
            row = n - 1
            col = 0

            # tc: O(n), at most n moves right + n moves up
            while row >= 0 and col < n:

                # Element <= x, count the whole column above it and move right:
                # matrix = [[1, 5, 9], [10, 11, 13], [12, 13, 15]], x = 13
                #   (2, 0) = 12 <= 13 -> count += 3, move right
                #   (2, 1) = 13 <= 13 -> count += 3, move right
                #   (2, 2) = 15 > 13  -> move up
                #   (1, 2) = 13 <= 13 -> count += 2, move right, out of range
                #   count = 8
                if matrix[row][col] <= x:
                    count += row + 1
                    col += 1

                # Element > x, the rest of the row is also > x, move up
                else:
                    row -= 1

            return count

        # Binary Search Boundaries (possible answer values)
        low = matrix[0][0]
        high = matrix[n - 1][n - 1]

        # tc: O(log(high - low)), each iteration does an O(n) count
        while low < high:

            # Middle value
            mid = low + (high - low) // 2

            # Enough elements <= mid, the answer is at most mid, keep mid as a candidate:
            # k = 8, matrix above
            #   low = 1, high = 15, mid = 8 -> countLessEqual(8) = 2 < 8 -> low = 9
            #   low = 9, high = 15, mid = 12 -> countLessEqual(12) = 6 < 8 -> low = 13
            #   low = 13, high = 15, mid = 14 -> countLessEqual(14) = 8 >= 8 -> high = 14
            #   low = 13, high = 14, mid = 13 -> countLessEqual(13) = 8 >= 8 -> high = 13
            #   low == high == 13
            if countLessEqual(mid) >= k:
                high = mid

            # Too few elements <= mid, the answer is greater than mid
            else:
                low = mid + 1

        # low == high, the smallest value whose count is >= k
        kthSmallest = low

        # overall: tc O(n log(max - min)), max and min are the largest and smallest values in the matrix
        # overall: sc O(1) for the pointers and counters
        return kthSmallest

    def kthSmallest(self, matrix: list[list[int]], k: int) -> int:

        # Binary Search (Sampled Median Pivot)

        # NOTE: This is a simplified, educational sketch inspired by Frederickson Johnson selection.
        # It is NOT a verified implementation of the paper, and it does NOT achieve true O(n).

        # Search Representation:
        #   - [low, high] is the range of possible values for the answer
        #   - Search is done when low == high, one candidate value remains

        # Idea:
        #   - Same value search as Solution 2, but the pivot is chosen from the matrix
        #     instead of always taking the middle of the value range
        #   - Pivot: take the middle element of every row (that row's median) and
        #     use the median of those medians, analogous to median of medians in 1D selection
        #   - Count elements <= pivot with the staircase count from Solution 2
        #   - If the count is >= k, high = pivot, otherwise low = pivot + 1
        #   - The pivot must land inside [low, high - 1] to shrink the range,
        #     otherwise fall back to the middle value, as in Solution 2

        # Number of rows and columns
        n = len(matrix)

        # Helper that counts elements <= x (same staircase count as Solution 2)
        def countLessEqual(x: int) -> int:

            # Elements <= x
            count = 0

            # Staircase Pointers (bottom left)
            row = n - 1
            col = 0

            # tc: O(n)
            while row >= 0 and col < n:

                # Element <= x, count the whole column above it and move right
                if matrix[row][col] <= x:
                    count += row + 1
                    col += 1

                # Element > x, move up
                else:
                    row -= 1

            return count

        # Helper that returns the median of the row medians
        def medianOfRowMedians() -> int:

            # Middle element of every row
            rowMedians = []

            # Row Pointer
            row = 0

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

                # Add row median
                rowMedians.append(matrix[row][n // 2])

                # Iterate rows
                row += 1

            # Median of the row medians
            # tc: O(n log n)
            rowMedians.sort()
            return rowMedians[n // 2]

        # Binary Search Boundaries (possible answer values)
        low = matrix[0][0]
        high = matrix[n - 1][n - 1]

        # tc: O(n log(max - min)) worst case, each iteration does an O(n) count
        while low < high:

            # Sampled pivot
            pivot = medianOfRowMedians()

            # Pivot can't shrink the range, fall back to the middle value:
            # matrix = [[1, 2], [3, 4]], k = 1
            #   low = 1, high = 4, pivot = 4 -> pivot >= high, so mid = 2
            #   without this check, count(4) = 4 >= 1 sets high = 4 forever (infinite loop)
            if pivot < low or pivot >= high:
                pivot = low + (high - low) // 2

            # Enough elements <= pivot, the answer is at most pivot
            if countLessEqual(pivot) >= k:
                high = pivot

            # Too few elements <= pivot, the answer is greater than pivot
            else:
                low = pivot + 1

        # low == high, the smallest value whose count is >= k
        kthSmallest = low

        # overall: tc O(n log(max - min)) worst case, the sampled pivot only helps on the first round
        #          because it is computed from the whole matrix, not the remaining range
        # overall: sc O(n) for the rowMedians list
        return kthSmallest

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

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

        # MinHeap (K Way Merge)

        # Heap Representation:
        #   - Maintain a minHeap of (fraction, i, j) candidates, one per numerator index i
        #   - Row i is the sorted list arr[i] / arr[n - 1], arr[i] / arr[n - 2], ..., arr[i] / arr[i + 1]
        #   - Root (minHeap[0]) is the smallest fraction among all candidates not yet taken
        #   - Heap is valid when it holds at most one candidate per row

        # Idea:
        #   - For a fixed i, arr[i] stays the same and arr[j] shrinks as j moves left,
        #     so the fraction strictly increases, which makes every row its own sorted list
        #   - Finding the kth smallest across these lists is the same k way merge as
        #     Kth Smallest In A Sorted Matrix, just walking denominators backward
        #   - Seed every row at j = n - 1, since the largest denominator gives
        #     the smallest fraction for that row
        #   - Pop the root k - 1 times to discard the k - 1 smallest fractions,
        #     and after each pop push the next candidate in the same row (i, j - 1),
        #     so each row always has exactly one candidate in the heap
        #   - After the k - 1 pops, the root is the kth smallest
        #   - A row is exhausted once j - 1 reaches i, since j must stay greater than i

        # Number of elements
        n = len(arr)

        # Index of the largest denominator
        lastIndex = n - 1

        # MinHeap of (fraction, i, j) candidates, one per row
        minHeap = []

        # Row Pointer
        row = 0

        # Seed each row with its smallest fraction, arr[row] / arr[lastIndex]
        # tc: O(n)
        while row < lastIndex:

            # Add first candidate of the row
            minHeap.append((arr[row] / arr[lastIndex], row, lastIndex))

            # Iterate rows
            row += 1

        # Order the seeds into a heap
        # tc: O(n)
        heapq.heapify(minHeap)

        # Discarded Pops
        popCount = 0

        # Discard the k - 1 smallest fractions
        # tc: O(k log n), k - 1 pops and pushes, each heap op is O(log n)
        while popCount < k - 1:

            # Smallest candidate
            fraction, i, j = heapq.heappop(minHeap)

            # Row has a next candidate, push it:
            # arr = [1, 2, 3, 5], k = 3
            #   seeds -> [(0.2, 0, 3), (0.4, 1, 3), (0.6, 2, 3)]
            #   pop (0.2, 0, 3), j - 1 = 2 > 0 -> push (1/3, 0, 2)
            #   pop (1/3, 0, 2), j - 1 = 1 > 0 -> push (1/2, 0, 1)
            #   k - 1 = 2 pops done, root is (0.4, 1, 3) -> [2, 5]
            # tc: O(log n)
            if j - 1 > i:
                heapq.heappush(minHeap, (arr[i] / arr[j - 1], i, j - 1))

            # Iterate pops
            popCount += 1

        # Kth smallest fraction (root)
        _, i, j = minHeap[0]

        # overall: tc O(n + k log n), seeding with heapify is O(n), k - 1 pops and pushes are O(k log n)
        # overall: sc O(n) for the heap
        return [arr[i], arr[j]]

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

    def lastStoneWeight(self, stones: list[int]) -> int:

        # MaxHeap (Negated MinHeap)

        # Heap Representation:
        #   - Maintain a maxHeap of every stone still in play, stored as negated weights
        #   - heapq is a minHeap, so negating weights makes the heaviest stone the root
        #   - Root (maxHeap[0]) is the negated weight of the heaviest stone
        #   - Heap is valid when it holds exactly the stones still in play

        # Idea:
        #   - Every round only the two heaviest stones matter, so a maxHeap gives them in O(log n)
        #   - Pop the two heaviest, smash them, and if they differ push the remainder back
        #   - Equal stones both vanish, so nothing is pushed
        #   - Each round removes two stones and adds back at most one,
        #     so the heap shrinks every round and the game ends
        #   - Stop when at most one stone remains, the root is the answer, or 0 if the heap is empty
        #   - heapify builds the heap from the negated list in O(n), cheaper than n pushes

        # MaxHeap of negated stone weights
        maxHeap = []

        # Stone Pointer
        index = 0

        # Negate each stone
        # tc: O(n)
        while index < len(stones):

            # Add negated weight
            maxHeap.append(-stones[index])

            # Iterate stones
            index += 1

        # Order the negated weights into a heap
        # tc: O(n)
        heapq.heapify(maxHeap)

        # tc: O(n log n), at most n - 1 rounds, each round is a constant number of O(log n) heap ops
        while len(maxHeap) > 1:

            # Two heaviest stones (undo the negation)
            heaviest = -heapq.heappop(maxHeap)
            secondHeaviest = -heapq.heappop(maxHeap)

            # Stones differ, push the remainder back:
            # stones = [2, 7, 4, 1, 8, 1]
            #   smash 8 and 7 -> 1, push -> [4, 2, 1, 1, 1]
            #   smash 4 and 2 -> 2, push -> [2, 1, 1, 1]
            #   smash 2 and 1 -> 1, push -> [1, 1, 1]
            #   smash 1 and 1 -> equal, both destroyed -> [1]
            #   one stone left -> 1
            # tc: O(log n)
            if heaviest != secondHeaviest:
                remainder = heaviest - secondHeaviest
                heapq.heappush(maxHeap, -remainder)

        # Last stone weight, 0 if every stone was destroyed
        lastStone = -maxHeap[0] if maxHeap else 0

        # overall: tc O(n log n)
        # overall: sc O(n) for the heap
        return lastStone

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

    def getOrder(self, tasks: list[list[int]]) -> list[int]:

        # MinHeap (Shortest Job First Simulation)

        # Heap Representation:
        #   - Maintain a minHeap of (processingTime, index) for every available task
        #   - A task is available once its enqueueTime <= clock
        #   - Root (minHeap[0]) is the shortest available task, and the smaller index
        #     wins ties because index is the second item of the tuple
        #   - Heap is valid when it holds exactly the released tasks that have not run yet

        # Idea:
        #   - The CPU wants the shortest available task, which is exactly what a minHeap
        #     keyed on (processingTime, index) gives in O(log n)
        #   - The tricky part is knowing which tasks are available at the current time,
        #     so sort task indexes by enqueueTime once, then sweep left to right with a pointer
        #   - Sort the indexes, not the tasks, since the answer reports original indexes
        #   - Each round, release every task with enqueueTime <= clock into the heap,
        #     then pop the shortest, record it, and advance the clock by its processingTime
        #   - If the heap is empty, nothing happens until the next task arrives,
        #     so jump the clock to that task's enqueueTime instead of idling one unit at a time
        #   - Each task is pushed once and popped once, so the heap work is O(n log n)

        # Number of tasks
        n = len(tasks)

        # Task indexes in order of enqueueTime
        # tc: O(n log n), the sort
        sortedIds = sorted(range(n), key=lambda taskId: tasks[taskId][0])

        # MinHeap of (processingTime, index) for available tasks
        minHeap = []

        # Order tasks run in
        result = []

        # Current time of the CPU
        clock = 0

        # Release Pointer (next task not yet released)
        taskPointer = 0

        # tc: O(n log n), each task is pushed once and popped once, each heap op is O(log n)
        while len(result) < n:

            # Release every task that has arrived by the current time:
            # tasks = [[1, 2], [2, 4], [3, 2], [4, 1]], clock = 3, taskPointer = 1
            #   task 1 (enqueue 2) -> push (4, 1)
            #   task 2 (enqueue 3) -> push (2, 2)
            #   task 3 (enqueue 4) -> 4 > 3, not yet released
            # tc: O(log n) per push
            while taskPointer < n and tasks[sortedIds[taskPointer]][0] <= clock:

                # Add available task
                taskId = sortedIds[taskPointer]
                heapq.heappush(minHeap, (tasks[taskId][1], taskId))

                # Iterate release pointer
                taskPointer += 1

            # Task available, run the shortest one
            if minHeap:

                # Shortest available task
                processingTime, taskId = heapq.heappop(minHeap)

                # Record task and advance the clock:
                # tasks = [[1, 2], [2, 4], [3, 2], [4, 1]]
                #   clock = 0, heap empty -> jump to 1
                #   run task 0 -> clock = 3
                #   run task 2 (shortest of (4, 1), (2, 2)) -> clock = 5
                #   run task 3 (shortest of (4, 1), (1, 3)) -> clock = 6
                #   run task 1 -> clock = 10, result = [0, 2, 3, 1]
                # tc: O(log n)
                result.append(taskId)
                clock += processingTime

            # Nothing available, jump the clock to the next arrival
            else:
                clock = tasks[sortedIds[taskPointer]][0]

        # overall: tc O(n log n), dominated by the sort and the heap operations
        # overall: sc O(n) for the sorted indexes, the heap, and the result
        return result

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

    def leastInterval(self, tasks: list[str], n: int) -> int:

        # Greedy (Math Formula)

        # Schedule Representation:
        #   - Lay the most frequent task out in maxFrequency groups
        #   - Each group is n + 1 intervals long: the task, then n intervals before it can repeat
        #   - The last group only holds the tasks tied for the max frequency,
        #     since nothing has to cool down after it
        #   - Other tasks fill the idle slots inside the groups

        # Idea:
        #   - The most frequent task decides the minimum schedule length, since its copies
        #     must be spaced n intervals apart
        #   - maxFrequency - 1 full groups of length n + 1, then one last group
        #     of maxFrequencyCount tasks
        #   - Other tasks slot into the idle gaps, so they cost no extra intervals
        #   - If there are more tasks than slots, the gaps overflow and no idle is needed,
        #     so the answer is just len(tasks), the lower bound
        #   - Answer is the max of the two

        # Frequency of each task
        frequency = defaultdict(int)

        # Task Pointer
        index = 0

        # Count each task
        # tc: O(N), N = len(tasks)
        while index < len(tasks):

            # Add task to count
            frequency[tasks[index]] += 1

            # Iterate tasks
            index += 1

        # Count of each task type
        counts = list(frequency.values())

        # Most copies of any one task
        maxFrequency = max(counts)

        # Number of task types tied for the most copies
        maxFrequencyCount = 0

        # Count Pointer
        countIndex = 0

        # tc: O(k), k = distinct tasks (at most 26)
        while countIndex < len(counts):

            # Task type is tied for the most copies
            if counts[countIndex] == maxFrequency:
                maxFrequencyCount += 1

            # Iterate counts
            countIndex += 1

        # Intervals forced by the most frequent tasks:
        # A, B share the max frequency 3, n = 2
        #   [A B idle] [A B idle] [A B] -> (3 - 1) * (2 + 1) + 2 = 8
        forcedIntervals = (maxFrequency - 1) * (n + 1) + maxFrequencyCount

        # More tasks than slots means no idle is needed, len(tasks) is the lower bound:
        # tasks = [A, C, A, B, D, B], n = 1
        #   forcedIntervals = (2 - 1) * (1 + 1) + 2 = 4, but there are 6 tasks -> answer 6
        minIntervals = max(forcedIntervals, len(tasks))

        # overall: tc O(N), N = len(tasks)
        # overall: sc O(k) for the frequency map, k <= 26 so effectively O(1)
        return minIntervals

    def leastInterval(self, tasks: list[str], n: int) -> int:

        # MaxHeap (Greedy Simulation With Cooldown)

        # Heap Representation:
        #   - Maintain a maxHeap of negated remaining counts, one per task type ready to run
        #   - heapq is a minHeap, so counts are negated to make the largest count the root
        #   - Root (maxHeap[0]) is the task type with the most copies left
        #   - Labels aren't stored, since only the counts decide the schedule
        #   - A task that just ran waits in a cooldown queue of (readyTime, remaining)

        # Idea:
        #   - Each loop is one CPU interval, so clock counts total intervals including idle
        #   - Run the task type with the most copies left, since it is the most at risk
        #     of forcing idle time later
        #   - If it has copies left, put it in the cooldown queue with readyTime = clock + n
        #   - A task ran at interval t can run again at t + n + 1, so it goes back into
        #     the heap at the end of interval t + n
        #   - One task runs per interval, so ready times are strictly increasing,
        #     and a FIFO queue is enough: at most one task becomes ready per interval
        #   - If the heap is empty but the queue is not, the CPU idles this interval
        #   - Stop when both the heap and the queue are empty

        # Frequency of each task
        frequency = defaultdict(int)

        # Task Pointer
        index = 0

        # Count each task
        # tc: O(N), N = len(tasks)
        while index < len(tasks):

            # Add task to count
            frequency[tasks[index]] += 1

            # Iterate tasks
            index += 1

        # MaxHeap of negated counts, one per task type
        maxHeap = []

        # Count of each task type
        counts = list(frequency.values())

        # Count Pointer
        countIndex = 0

        # Seed each task type with its negated count
        # tc: O(k), k = distinct tasks (at most 26)
        while countIndex < len(counts):

            # Add negated count
            maxHeap.append(-counts[countIndex])

            # Iterate counts
            countIndex += 1

        # Order the seeds into a heap
        # tc: O(k)
        heapq.heapify(maxHeap)

        # Tasks waiting out their cooldown as (readyTime, remaining)
        cooldown = deque()

        # Intervals used so far
        clock = 0

        # tc: O(T log k), T = intervals used (the answer), each interval does at most 2 heap ops
        while maxHeap or cooldown:

            # One CPU interval
            clock += 1

            # A task is ready, run the one with the most copies left
            if maxHeap:

                # Remove most frequent task, use one copy (counts are negated, so + 1)
                remaining = heapq.heappop(maxHeap) + 1

                # Copies left, wait out the cooldown
                if remaining != 0:
                    cooldown.append((clock + n, remaining))

            # Front of the queue finished its cooldown, push it back:
            # tasks = [A, A, A, B, B, B], n = 2
            #   clock 1: run A -> cooldown [(3, -2)]
            #   clock 2: run B -> cooldown [(3, -2), (4, -2)]
            #   clock 3: heap empty, idle, A ready -> push -2
            #   clock 4: run A -> cooldown [(4, -2), (6, -1)], B ready -> push -2
            #   clock 5: run B -> cooldown [(6, -1), (7, -1)]
            #   clock 6: idle, A ready -> push -1
            #   clock 7: run A, B ready -> push -1
            #   clock 8: run B, both empty -> 8
            # n = 0: readyTime = clock, so it is pushed back the same interval
            # tc: O(log k)
            if cooldown and cooldown[0][0] == clock:

                # Pop FIFO
                _, remaining = cooldown.popleft()

                # Add task type back to the heap
                heapq.heappush(maxHeap, remaining)

        # overall: tc O(T log k), T = answer, k <= 26 so effectively O(T)
        # overall: sc O(k) for the heap and cooldown queue
        return clock