Problems

len(set(nums)) != len(nums)

Arrays & Hashing · hash set

Counter(s) == Counter(t)

Arrays & Hashing · frequency

store value→index; check complement before inserting

Arrays & Hashing · hash map

key = sorted string, or a 26-length count tuple for O(n·k)

Arrays & Hashing · hash + canonical key

bucket by frequency → O(n), beats the heap's O(n log k)

Arrays & Hashing · heap / bucket

length-prefix each string (4#word); delimiters alone are ambiguous

Arrays & Hashing · serialization

left pass then right pass, O(1) extra space

Arrays & Hashing · prefix/suffix

three dicts of sets; box key is (r//3, c//3)

Arrays & Hashing · hash sets

only start counting from x where x-1 isn't in the set

Arrays & Hashing · hash set

skip non-alphanumeric, compare lowercase

Two Pointers · converging

sum too small → move left up; too big → move right down

Two Pointers · converging

fix one anchor; dedup twice (anchors and after a hit)

Two Pointers · sort + two pointers

always move the shorter line — moving the taller can't help

Two Pointers · converging greedy

water at i = min(left_max, right_max) - h[i]; advance the smaller side

Two Pointers · two pointers

track the min so far; profit = price − min

Sliding Window · running min

last-seen index map; guard last[c] >= left

Sliding Window · variable window

valid iff window_len - max_freq <= k

Sliding Window · variable window

window of len(s1), compare frequency counts

Sliding Window · fixed window

formed/required counters make validity O(1)

Sliding Window · variable window

deque of indices, values decreasing; front is the max

Sliding Window · monotonic deque

push openers; on a closer, the top must match

Stack · stack

parallel stack of running minimums

Stack · auxiliary stack

pop two, apply, push; int(a/b) truncates toward zero

Stack · stack

rule: open < n to add '(', close < open to add ')'

Stack · backtracking

decreasing stack of indices; answer is the index distance

Stack · monotonic stack

sort by position descending; a slower car ahead absorbs you

Stack · monotonic stack

increasing stack of (start_index, height), then drain

Stack · monotonic stack

inclusive bounds, lo <= hi, always exclude mid

Binary Search · template

treat as one array: row = i // cols, col = i % cols

Binary Search · flatten

monotonic: if speed k works, every speed > k works

Binary Search · search the answer

compare nums[mid] to nums[hi], never to nums[lo]

Binary Search · modified BS

one half is always sorted — find it, then test containment

Binary Search · modified BS

dict of sorted lists + bisect_right - 1

Binary Search · BS on timestamps

binary search the split point of the smaller array

Binary Search · BS on partition

prev / curr / next, 4 lines — memorize

Linked List · pointer reversal

compare heads, advance the smaller

Linked List · dummy head

find middle → reverse second half → interleave

Linked List · composition

fast leads slow by n; dummy head handles head removal

Linked List · gap pointers

old→new map, then a second pass wiring pointers

Linked List · hash map

loop while either list or a carry remains

Linked List · dummy + carry

they meet iff a cycle exists

Linked List · fast/slow

treat values as next pointers → cycle detection

Linked List · Floyd's

sentinel head/tail; nodes must store their key for eviction

Linked List · hashmap + DLL

heap of k heads, (val, i, node) — index breaks ties

Linked List · heap

count k ahead first; reverse the block; reconnect

Linked List · pointer surgery

swap children, recurse

Trees · any traversal

1 + max(left, right)

Trees · postorder

record l + r, return 1 + max(l, r)

Trees · postorder

fuse height + balance; -1 sentinel propagates failure

Trees · postorder

compare structure and value simultaneously

Trees · parallel recursion

at each node, run isSameTree

Trees · nested recursion

walk down while both targets are on the same side

Trees · BST property

snapshot len(q) to process exactly one level

Trees · BFS

last node of each level

Trees · BFS

pass max_so_far down

Trees · preorder

inherit (low, high) — local checks are wrong

Trees · preorder bounds

iterative inorder lets you stop early, O(h+k)

Trees · inorder

index map for O(1) root lookup → O(n)

Trees · divide & conquer

clamp negative branches to 0; return one side only

Trees · postorder

# for null encodes the shape

Trees · preorder + markers

children dict + is_word flag

Tries · trie

. recurses into every child

Tries · trie + DFS

one grid DFS; prune when the prefix leaves the trie

Tries · trie + backtracking

the root is the k-th largest

Heap / Priority Queue · min-heap size k

negate values for Python's min-heap

Heap / Priority Queue · max-heap

compare squared distance — no sqrt needed

Heap / Priority Queue · heap

heap O(n log k); quickselect O(n) average

Heap / Priority Queue · heap / quickselect

most frequent task first; or the closed-form gap formula

Heap / Priority Queue · greedy + heap

merge the k followed feeds by timestamp

Heap / Priority Queue · heap merge

max-heap low half, min-heap high half, rebalance ritual

Heap / Priority Queue · two heaps

every node is an answer; start prevents reordering

Backtracking · backtracking

backtrack(i, ...) — same index allows reuse

Backtracking · backtracking

used[] array; scan all indices since order matters

Backtracking · backtracking

sort, then if i > start and a[i]==a[i-1]: continue

Backtracking · backtracking + dedup

sort + dedup + backtrack(i+1) for single use

Backtracking · backtracking + dedup

mark the cell, recurse, unmark

Backtracking · grid backtracking

try each prefix; recurse only if it's a palindrome

Backtracking · backtracking

digit→letters map, recurse by index

Backtracking · backtracking

conflict sets on col, r-c, r+c

Backtracking · backtracking + pruning

sink each island on visit; count the starts

Graphs · flood fill

DFS returns a size

Graphs · flood fill

old→new map doubles as the visited set

Graphs · DFS + hash map

seed the queue with every gate

Graphs · multi-source BFS

count levels; track remaining fresh

Graphs · multi-source BFS

flow outward from each ocean, then intersect

Graphs · reverse BFS/DFS

mark from the border, then flip the rest

Graphs · boundary DFS

processed count < n → a cycle exists

Graphs · topological sort

Kahn's, return the order

Graphs · topological sort

connected and exactly n-1 edges

Graphs · union-find / DFS

count decrements on each successful union

Graphs · union-find

the edge where union returns False

Graphs · union-find

bucket by wildcard patterns (ht) to build adjacency

Graphs · BFS on states

Eulerian path; append on dead-end, reverse at the end

Advanced Graphs · Hierholzer's

heap of (distance, node)

Advanced Graphs · Prim's MST

answer is the max of all final distances

Advanced Graphs · Dijkstra

minimize the maximum edge along the path

Advanced Graphs · Dijkstra variant

derive edges from the first differing char of adjacent words

Advanced Graphs · topological sort

exactly k+1 rounds; relax from a snapshot

Advanced Graphs · Bellman-Ford

it's Fibonacci

1-D Dynamic Programming · linear DP

dp[i] = cost[i] + min(dp[i-1], dp[i-2])

1-D Dynamic Programming · linear DP

max(skip, rob + dp[i-2])

1-D Dynamic Programming · linear DP

circular → run linear on nums[:-1] and nums[1:]

1-D Dynamic Programming · linear DP ×2

2n−1 centers, O(1) space, beats the DP

1-D Dynamic Programming · expand around center

same loop, count instead of measure

1-D Dynamic Programming · expand around center

add one-digit and two-digit options; guard leading '0'

1-D Dynamic Programming · linear DP

dp[0]=0, minimize; unreachable stays inf

1-D Dynamic Programming · unbounded knapsack

track min and max — a negative flips them

1-D Dynamic Programming · linear DP

dp[i] true if some dp[j] true and s[j:i] is a word

1-D Dynamic Programming · segmentation DP

dp[i] = LIS ending at i; then bisect for O(n log n)

1-D Dynamic Programming · LIS

reachable-sum set; odd total → immediate False

1-D Dynamic Programming · 0/1 knapsack

one row rolling: dp[j] += dp[j-1]

2-D Dynamic Programming · grid DP

match → diagonal+1; else max of the two neighbors

2-D Dynamic Programming · two-sequence

three states: hold, sold, rest

2-D Dynamic Programming · state machine

coin loop outside counts combinations, not permutations

2-D Dynamic Programming · unbounded knapsack

dp[(index, running_sum)], memoized

2-D Dynamic Programming · 0/1 knapsack

dp[i][j]: can s3[:i+j] be formed from s1[:i] + s2[:j]

2-D Dynamic Programming · two-sequence

DAG by strict increase → no visited set needed

2-D Dynamic Programming · DFS + memo

match → dp[i-1][j-1] + dp[i-1][j]; else dp[i-1][j]

2-D Dynamic Programming · two-sequence

three-way min: replace, delete, insert

2-D Dynamic Programming · two-sequence

think about which balloon bursts last

2-D Dynamic Programming · interval DP

→ zero occurrences, or one more if chars match

2-D Dynamic Programming · two-sequence

curr = max(x, curr + x) — restart or extend

Greedy · Kadane's

fail if i > furthest_reachable

Greedy · greedy reach

BFS by level without a queue

Greedy · greedy levels

on a deficit, no station in the failed span can start

Greedy · greedy reset

the smallest remaining card must start a group

Greedy · greedy

ignore any triplet exceeding the target in any position

Greedy · greedy filter

extend to the last occurrence of every char seen

Greedy · greedy interval

track [min_open, max_open]; widens the range

Greedy · greedy range

three phases: before / absorb / after — no sort needed

Intervals · interval merge

extend the last interval when it overlaps

Intervals · sort by start

interval scheduling — earliest end leaves the most room

Intervals · sort by end

check each adjacent pair

Intervals · sort by start

min-heap of end times, or separate sorted start/end arrays

Intervals · sweep / heap

sort queries, push intervals as they become active

Intervals · sort + heap

reverse rows, then transpose

Math & Geometry · matrix

four shrinking bounds + two guards for single row/col

Math & Geometry · matrix

use row 0 / col 0 as markers, then fill backward

Math & Geometry · matrix, O(1) space

fast/slow, or a seen-set

Math & Geometry · cycle detection

propagate the carry from the right

Math & Geometry · array math

square the base, halve the exponent

Math & Geometry · binary exponentiation

res[i+j+1] += d1d2, then carry

Math & Geometry · array math

count points; for each diagonal partner, multiply counts

Math & Geometry · hash counting

pairs cancel to 0

Bit Manipulation · XOR

n &= n-1 clears the lowest set bit

Bit Manipulation · bit trick

dp[i] = dp[i>>1] + (i&1)

Bit Manipulation · DP + bits

shift out of one end, into the other

Bit Manipulation · bit trick

XOR indices with values, or n(n+1)/2 − sum

Bit Manipulation · XOR / math

XOR = sum without carry; (a&b)<<1 = carry; loop

Bit Manipulation · bit arithmetic

check 32-bit bounds before the final digit

Bit Manipulation · overflow

two nested anchors → O(n³)

Very frequently asked (do all of these) 🔥 · two pointers

union by shared email, group by root

Very frequently asked (do all of these) 🔥 · union-find

carry propagation from the right, as strings

Bit Manipulation · bit arithmetic

convert the tree into a graph

Trees & Tries, extended · build parent links + BFS

DLL of frequency buckets

Design / OOP-flavored · Design / OOP-flavored

resolve collisions while pushing

Very frequently asked (do all of these) 🔥 · stack

straight simulation

Stack · stack

push signed terms; handle and / immediately

Very frequently asked (do all of these) 🔥 · stack

take every upward step: sum of all positive deltas

Arrays & Hashing · greedy

dp[day][transactions][holding]

DP, extended · state machine + k

subtract the fee on sale

DP, extended · state machine

go left, pop, go right

Very frequently asked (do all of these) 🔥 · stack

do preorder as node→right→left, then reverse

Trees · iterative stack

push right before left

Trees · iterative stack

track a column index per node

Trees & Tries, extended · BFS + column map

reverse alternate levels

Very frequently asked (do all of these) 🔥 · BFS

the answer is the shared high-bit prefix of left and right

Bit Manipulation · common prefix

pair the lightest with the heaviest if they fit; else the heaviest goes alone

Two Pointers · sort + converge

independently order rows and columns, then place

Advanced Graphs · topological sort ×2

barriers, resource counting

Concurrency (Amazon, some backend loops) · Concurrency (Amazon, some backend loops)

same shape as Koko

Very frequently asked (do all of these) 🔥 · BS on the answer

two paths simultaneously, indexed by step

DP, extended · 3-D DP

amount loop outside → counts permutations (contrast with Coin Change II)

1-D Dynamic Programming · unbounded knapsack

split, pad the shorter with zeros

Strings · parsing

nums + nums; state the O(n) anyway

Arrays & Hashing · warm-up

if the quadrant is uniform it's a leaf, else recurse into four

Trees · divide & conquer

see file 02

Very frequently asked (do all of these) 🔥 · two pointers

keep a set of the last k elements; evict as you slide

Sliding Window · window + set

mid becomes the root

Trees & Tries, extended · divide & conquer

state machine over the 5 vowels

DP, extended · linear DP

transitive reachability

Graphs, extended · Floyd-Warshall / DFS

low[child] > disc[node]

Graphs, extended · Tarjan

push counts and partial strings on [

Very frequently asked (do all of these) 🔥 · two stacks

delete children first, then re-check yourself

Trees · postorder

two children → replace with the inorder successor

Trees & Tries, extended · BST surgery

two stacks or a DLL

Design / OOP-flavored · Design / OOP-flavored

fixed array with wraparound

Design / OOP-flavored · Design / OOP-flavored

trie of paths

Design / OOP-flavored · Design / OOP-flavored

same, storing (key, value) pairs

Arrays & Hashing · design

array of buckets + chaining; explain your collision strategy

Arrays & Hashing · design

evict timestamps older than 300s

Very frequently asked (do all of these) 🔥 · deque

nested dict tree

Design / OOP-flavored · Design / OOP-flavored

cache the top-3 at each trie node

Trees & Tries, extended · trie + heap

row/col/diagonal counters, O(1) per move

Design / OOP-flavored · Design / OOP-flavored

in-progress trips + route totals

Very frequently asked (do all of these) 🔥 · two hash maps

deadlock avoidance via lock ordering

Concurrency (Amazon, some backend loops) · Concurrency (Amazon, some backend loops)

simulate bans round by round, re-queueing survivors at i + n

Greedy · two queues

fill from the destination backward

DP, extended · reverse DP

counter/base62 + two maps

Design / OOP-flavored · Design / OOP-flavored

edge weight = the ratio; multiply along the path

Graphs, extended · weighted graph DFS

1-indexed, so decrement before each divmod

Math & Geometry · base-26

dp[i] = min extra chars from i; walk the trie forward from each index

Tries · trie + DP

compare count arrays

Very frequently asked (do all of these) 🔥 · fixed window

critical = MST weight rises without it; pseudo = forcing it in keeps the weight

Advanced Graphs · Kruskal ×3

nodes that can't reach a cycle

Graphs, extended · reverse topo / colors

find the peak, then search ascending, then descending

Binary Search · BS ×3

search for the best left boundary in [0, n-k]

Sliding Window · binary search the window

move toward the higher neighbor

Very frequently asked (do all of these) 🔥 · BS without sorting

judge has indegree n−1 and outdegree 0

Graphs · degree counting

lo < hi, hi = mid

Very frequently asked (do all of these) 🔥 · boundary BS

place each value at index v-1, then scan

Arrays & Hashing · cyclic sort

build right-skewed, prev pointer

Very frequently asked (do all of these) 🔥 · reverse postorder

(position, last_jump)

DP, extended · DP with a state set

the answer exists iff a+b == b+a; length is gcd(len(a), len(b))

Math & Geometry · gcd

union each number with each of its prime factors; connected ⟺ traversable

Advanced Graphs · union-find over prime factors

normalize by the offset from the first char

Strings · canonical key

pure binary search against an API

Binary Search · template

return (rob_this, skip_this) from each node

Trees & Tries, extended · tree DP

amortized O(1) via lazy transfer

Very frequently asked (do all of these) 🔥 · two stacks

rotate after each push

Very frequently asked (do all of these) 🔥 · one queue

naive O(nm) usually accepted

Strings · KMP or Rabin-Karp

swap-with-last on removal

Very frequently asked (do all of these) 🔥 · array + index map

splice a node between each adjacent pair

Math & Geometry · traversal + gcd

descend until a null child, attach there

Trees · BST walk

dp[n] = max(i dp[n-i], i (n-i)); the math answer is "use as many 3s as possible"

1-D Dynamic Programming · linear DP

conflict → odd cycle exists

Graphs, extended · BFS coloring

4 per land cell, minus 2 for each shared edge

Graphs · grid scan

track the furthest reachable index and a window of valid launch points

Greedy · BFS / sliding window

binary search the value, count elements ≤ mid

Very frequently asked (do all of these) 🔥 · heap / BS on value

found in both subtrees → this node is the LCA

Trees & Tries, extended · postorder

always give the largest bills first, keeping small change in reserve

Greedy · greedy

two maps + frequency buckets — the LRU follow-up

Design / OOP-flavored · Design / OOP-flavored

hashmap of last-seen timestamps

Design / OOP-flavored · Design / OOP-flavored

compare column by column

Strings · scan

binary search the length

Strings · rolling hash + BS

take the most frequent letter unless it would make three in a row, then take the second

Heap / Priority Queue · greedy + max-heap

LCS of s and s[::-1]

Very frequently asked (do all of these) 🔥 · 2-D DP

shrink while len(window) > k

Very frequently asked (do all of these) 🔥 · sliding window

two running lengths: last comparison was up, or down

Greedy · state DP

candidate + count; the majority survives cancellation

Very frequently asked (do all of these) 🔥 · Boyer-Moore

at most two elements can exceed n/3, so track two candidates

Arrays & Hashing · Boyer-Moore ×2

pre-size each island, then test each 0

Graphs, extended · union-find

4 buckets to a fixed target; sort descending to prune hard

Backtracking · bitmask / backtracking

run Largest Rectangle on each row

DP, extended · histogram per row

dp[i][j] = 1 + min(up, left, diagonal)

DP, extended · 2-D DP

freq[x] plus group[f] = a stack of values seen f times

Stack · stacks by frequency

answer = max(normal Kadane, total − min subarray); guard the all-negative case

Greedy · Kadane ×2

index children as 2i / 2i+1

Trees & Tries, extended · BFS + indices

greedily walk the opposite bit at each level

Trees & Tries, extended · bitwise trie

one heap of free rooms by index, one of busy rooms by end time

Intervals · two heaps

fill from the end to avoid overwriting

Very frequently asked (do all of these) 🔥 · two pointers backward

walk both, append the remainder

Two Pointers · parallel pointers

keep n's bits in the positions where x has zeros

Bit Manipulation · bit construction

three predecessors per cell

DP, extended · grid DP

strip leaves until ≤ 2 nodes remain

Graphs, extended · topological peeling

accumulate in place

DP, extended · grid DP

shrink while sum >= target

Very frequently asked (do all of these) 🔥 · sliding window

swap non-zeros forward

Very frequently asked (do all of these) 🔥 · read/write pointers

deque + running sum

Design / OOP-flavored · Design / OOP-flavored

identical to N-Queens, return only the count — no board needed

Backtracking · backtracking

three rolling variables instead of two

1-D Dynamic Programming · linear DP

islands appear incrementally

Graphs, extended · union-find

track length and count arrays

DP, extended · LIS + counts

count components in an adjacency matrix

Very frequently asked (do all of these) 🔥 · union-find

two capacity dimensions

DP, extended · 2-D knapsack

pop smaller prices, accumulating their spans

Stack · monotonic stack

each combination is a node

Graphs, extended · BFS on states

maximize the product instead of minimizing a sum

Graphs, extended · Dijkstra variant

minimise the largest single step, not the sum

Advanced Graphs · Dijkstra on max-edge

coins are the square numbers

DP, extended · unbounded knapsack

use the already-linked level above

Very frequently asked (do all of these) 🔥 · BFS / level links

two semaphores ping-ponging

Concurrency (Amazon, some backend loops) · Concurrency (Amazon, some backend loops)

semaphores / events

Concurrency (Amazon, some backend loops) · Concurrency (Amazon, some backend loops)

binary search the cumulative array

Very frequently asked (do all of these) 🔥 · prefix + bisect

pre[r][c] = sum of the rectangle from origin; inclusion–exclusion for a query

Arrays & Hashing · 2-D prefix sum

find the two swapped nodes in the sorted sequence

Trees & Tries, extended · inorder

write index trails read

Very frequently asked (do all of these) 🔥 · read/write pointers

pop larger digits while budget remains

Very frequently asked (do all of these) 🔥 · monotonic stack

n % (n - lps[-1]) == 0

Strings · KMP

dummy head, walk to left-1, reverse right-left nodes by head-insertion

Linked List · pointer surgery

swap ends inward, in place

Two Pointers · converging

" ".join(s.split()[::-1])

Strings · parsing

add each value; subtract twice when a smaller numeral precedes a larger

Math & Geometry · parsing

reverse all, reverse first k, reverse rest → O(1) space

Two Pointers · reversal trick

sort widths asc, heights desc to block ties

DP, extended · sort + LIS

start top-right; move left or down

Very frequently asked (do all of these) 🔥 · staircase

duplicates break the "which half is sorted" test; shrink lo/hi when nums[lo]==nums[mid]==nums[hi] → O(n) worst case

Binary Search · modified BS

the answer is lo when the loop exits

Binary Search · boundary template

preorder + child counts

Design / OOP-flavored · Design / OOP-flavored

grid BFS

Graphs, extended · BFS 8-directional

split on /, pop on ..

Very frequently asked (do all of these) 🔥 · stack

sort by enqueue time; heap of available tasks by (duration, index); jump the clock when idle

Heap / Priority Queue · sort + heap

serialize the board as a string key

Graphs, extended · BFS on board states

per-index (snap_id, value) list + bisect

Design / OOP-flavored · Design / OOP-flavored

implement merge sort — see 11 §11.1

Arrays & Hashing · sorting

low/mid/high partition in one pass

Very frequently asked (do all of these) 🔥 · three pointers

feasibility check = greedy chunking

Very frequently asked (do all of these) 🔥 · BS on the answer

score-difference formulation over 1–3 stones

1-D Dynamic Programming · game theory DP

whitespace → sign → digits → clamp

Strings · parsing

seed {0: 1}; count running - k

Very frequently asked (do all of these) 🔥 · prefix + hash

or the O(n) math: every bit appears in exactly half the subsets

Backtracking · subsets

carry the running number down

Trees & Tries, extended · preorder

compare left.left with right.right

Very frequently asked (do all of these) 🔥 · parallel recursion

careful spacing; last line is left-justified

Strings · simulation

list(zip(matrix)) — note it handles non-square, unlike an in-place swap

Math & Geometry · matrix

fill bottom-up, in place

DP, extended · grid DP

track the closest sum seen

Very frequently asked (do all of these) 🔥 · two pointers

obstacle cell → 0 ways

DP, extended · grid DP

enumerate the states explicitly

Strings · state machine / regex

map each letter to its rank, compare adjacent words

Graphs · ordering

thread pool + a shared visited set with a lock

Concurrency (Amazon, some backend loops) · Concurrency (Amazon, some backend loops)

return all segmentations; memoise by start index or it explodes

Backtracking · backtracking + memo

two maps, both directions

Strings · bijection

mark/unmark

Very frequently asked (do all of these) 🔥 · backtracking

bounce a row pointer

Strings · simulation