The 60-day DSA sheet: 120 LeetCode problems, learned by pattern.

Idea: Store each number's index in a map; look up target minus current.

Idea: A set tells you instantly if you have seen a value.

Idea: Count letters in both strings; the counts must match.

Idea: Sorted word (or letter counts) as the map key.

Idea: Boyer–Moore voting: a candidate and a counter.

Idea: k %= n, then reverse all, reverse first k, reverse the rest.

Idea: Prefix product from the left times suffix product from the right.

Idea: Count, then bucket by frequency instead of sorting.

Idea: Only start counting from numbers whose n−1 is not in the set.

Idea: One set per row, column and 3×3 box.

Idea: Skip non-letters, compare from both ends inward.

Idea: Slow pointer i keeps uniques; fast pointer j scans.

Idea: Sum too small? Move left. Too big? Move right.

Idea: Write every non-zero forward, then fill the tail with zeros.

Idea: Sort, fix one number, run Two Sum II on the rest, skip duplicates.

Idea: Dutch flag: low, mid and high pointers.

Idea: Water at i = min(max left, max right) − height; move the smaller side.

Idea: Always move the shorter wall inward.

Idea: Fixed window: add the new element, drop the old one.

Idea: Track the lowest price so far; profit = today − lowest.

Idea: Shrink from the left until the repeated character leaves.

Idea: Expand until sum ≥ target, then shrink while it still holds.

Idea: Fixed window of letter counts compared with the target's counts.

Idea: Valid while window − max count ≤ k.

Idea: Count how many required letters are satisfied; shrink when all are.

Idea: Monotonic deque of indexes, biggest at the front.

Idea: sum(i..j) = prefix[j+1] − prefix[i].

Idea: Each value becomes itself plus everything before it.

Idea: Count how often prefix − k has appeared in a map.

Idea: Left sum == total − left sum − current.

Idea: Count 0 as −1; the same prefix sum seen twice means a balanced subarray.

Idea: Kadane: drop the running sum when it turns negative.

Idea: Check the middle; throw away the half that cannot contain the target.

Idea: When the loop ends, low is where the target belongs.

Idea: Two searches: keep going left for the first, right for the last.

Idea: Treat the matrix as one sorted array: row = mid / cols.

Idea: One half is always sorted; check if the target is inside it.

Idea: Compare mid with the right end to find the unsorted half.

Idea: Binary search on the speed, not the array.

Idea: Search the capacity; test if it ships in D days.

Idea: Store the minimum so far alongside every value.

Idea: Push openers; every closer must match the top.

Idea: Numbers go on the stack; an operator pops two.

Idea: Add '(' while opens < n, ')' while closes < opens.

Idea: Decreasing stack of indexes; a warmer day pops and answers them.

Idea: Monotonic stack over nums2, answers stored in a map.

Idea: Sort by position; a slower car ahead absorbs the ones behind.

Idea: Increasing stack; a shorter bar closes every taller rectangle.

Idea: prev, curr, next: flip one arrow at a time.

Idea: Dummy head; always attach the smaller node.

Idea: Fast moves 2, slow moves 1; slow ends in the middle.

Idea: Tortoise and hare: if they meet, there is a loop.

Idea: Move fast n steps ahead, then move both together.

Idea: Find the middle, reverse the second half, merge alternately.

Idea: Hash map + doubly linked list; move used items to the front.

Idea: Add digit by digit with a carry, like school addition.

Idea: f(n) = f(n−1) + f(n−2); see why plain recursion repeats work.

Idea: Halve n each call: x^n = (x^(n/2))².

Idea: For each element: take it or skip it.

Idea: Sort, then skip a duplicate at the same depth.

Idea: Pick any unused number for the next slot.

Idea: Reuse the same index; stop when the sum passes the target.

Idea: One queen per row; sets for columns and both diagonals.

Idea: DFS from each cell; mark visited, then unmark on the way back.

Idea: Swap left and right at every node.

Idea: 1 + max(depth of left, depth of right).

Idea: At each node, left height + right height is a candidate.

Idea: Same value, same left subtree, same right subtree.

Idea: BFS: process the queue one level size at a time.

Idea: Return −1 up the tree as soon as heights differ by more than 1.

Idea: If both sides return a node, the current node is the answer.

Idea: Last node of each BFS level.

Idea: Preorder gives the root; its inorder position splits left and right.

Idea: Return the best one-sided path; record the best two-sided one.

Idea: Go left if smaller, right if bigger.

Idea: The middle element is the root; build both halves the same way.

Idea: Pass down the allowed (min, max) range.

Idea: Inorder traversal visits values in sorted order.

Idea: Where p and q split to different sides is the answer.

Idea: Two children? Replace with the smallest value on the right.

Idea: Max-heap: smash the two biggest, push the difference.

Idea: Keep a min-heap of size k; its top is the answer.

Idea: Min-heap of size k, or quickselect.

Idea: Max-heap of size k by distance (no square root needed).

Idea: Two heaps: max-heap for the low half, min-heap for the high half.

Idea: The most frequent task decides the gaps you must fill.

Idea: Every unvisited land cell starts a DFS that sinks its island.

Idea: DFS/BFS from the start cell to same-coloured neighbours.

Idea: Multi-source BFS from every rotten orange at once.

Idea: DFS returns the size of each island.

Idea: Map old node → new node so you never copy one twice.

Idea: Search backwards from each ocean, then intersect.

Idea: A cycle in the prerequisite graph means it is impossible.

Idea: Kahn's algorithm: repeatedly take courses with no prerequisites left.

Idea: Dijkstra from the source; answer is the farthest arrival.

Idea: BFS over words; neighbours differ by one letter.

Idea: Track the farthest index you can reach.

Idea: BFS by ranges: count jumps when you pass the current range's end.

Idea: Sort by start; merge when the next starts before the last ends.

Idea: Add the ones before, merge the overlapping ones, add the rest.

Idea: Sort by end; keep the interval that finishes earliest.

Idea: Record each letter's last index; cut when you reach the farthest one.

Idea: ways(n) = ways(n−1) + ways(n−2).

Idea: cost to reach i = cost[i] + min of the two steps below.

Idea: At each house: rob it plus i−2, or skip it and keep i−1.

Idea: Circle: run House Robber without the first, then without the last.

Idea: dp[amount] = 1 + min dp[amount − coin].

Idea: Loop coins outside, amounts inside, to count combinations.

Idea: dp[i] = 1 + best dp[j] with nums[j] < nums[i].

Idea: dp[i] is true if some word ends at i after a true dp[j].

Idea: Paths to a cell = paths from above + paths from the left.

Idea: Letters match: 1 + diagonal; otherwise the max of up or left.

Idea: Can a subset reach total / 2? 0/1 knapsack on sums.

Idea: Track both max and min so far; a negative swaps them.

Idea: Expand around every centre (odd and even lengths).

Idea: Insert, delete or replace: 1 + min of the three neighbours.

Idea: XOR everything: pairs cancel to 0, the single number stays.

Idea: XOR every index and value: pairs cancel, the missing number is left.

Idea: Each node: children by letter plus an end-of-word flag.

Idea: n & (n − 1) removes the lowest set bit; count the steps.