Problems
Callback's own problems and the LeetCode questions companies have been asking, in one place — pick a category, then filter by company, frequency, status, difficulty, topic, and language.
Algorithms & Data Structures · Greedy line packing and fiddly space math — full text justification.
Algorithms & Data Structures · Arbitrary-precision rounding — floats need not apply.
Algorithms & Data Structures · Streaming design: recent counts, top-k, and sliding-window bans.
Algorithms & Data Structures · Order and duplicates vanish at every depth — canonicalize.
Assign Pins to Shortest Columns
Algorithms & Data Structures · The masonry-layout greedy: shortest column wins, leftmost on ties.
Collect Pins from Reachable Boards
Algorithms & Data Structures · BFS over the bipartite pin-board graph without building board-to-board edges.
Algorithms & Data Structures · Reassemble lines from arbitrary chunks, reading lazily.
Algorithms & Data Structures · Advance players in O(1), rank them without sorting — a linked list per room.
Algorithms & Data Structures · Meet new group sizes while disrupting as few buckets as possible.
Algorithms & Data Structures · Interval sweep for the free ranges — independent of bucket-space size.
Algorithms & Data Structures · Smallest-free allocation under a capacity that moves at runtime.
Cross-Reference Logs to Flag Spam Numbers
Algorithms & Data Structures · A hash join across two logs — and saying that word out loud.
Sparse Matrix Storage, Addition, and Multiplication
Algorithms & Data Structures · Storage proportional to nonzeros — and the cancellation trap.
Select the Nearest Eligible Elevator
Algorithms & Data Structures · A requirements-gathering problem wearing a simulation costume.
Decide Target via Subsequence Plus/Multiply Expression
Algorithms & Data Structures · Expression search with precedence — the (total, pending product) trick.
Compute Reachable Cells for a Cleaning Robot
Algorithms & Data Structures · Slide-until-blocked physics: rest positions are the states, not cells.
Maximize Boxes Stored Through One Entrance
Algorithms & Data Structures · Prefix-min ceilings plus an exchange-argument greedy.
Mark and Compact a Heap-Indexed Subtree
Algorithms & Data Structures · Garbage collection in miniature: mark a subtree, compact, remap.
Implement Single-Tab Browser History Navigation
Algorithms & Data Structures · A cursor over one visit stack: truncate forward history, clamp at both ends.
Algorithms & Data Structures · Pack named ID ranges, then resize with all-or-nothing shifts.
Algorithms & Data Structures · Net the balances, then match debtors to creditors greedily.
Algorithms & Data Structures · Use every ticket once: Hierholzer's walk, smallest destination first.
Algorithms & Data Structures · Two sorted indexes and a binary search you write by hand.
Algorithms & Data Structures · BFS over routes, not stops — clear each stop as you expand it.
Algorithms & Data Structures · Two out-edges per index: a graph search with a visited array.
Restaurant Seating: Free Intervals
Algorithms & Data Structures · A +ppl/−ppl sweep; occupancy is constant between events.
Count Pins on a Two-Column Screen
Algorithms & Data Structures · Only n scroll offsets matter — slide the window to a pin's top.
Count Subarrays with Score Below K
Algorithms & Data Structures · Positives make sum × length monotone — a two-pointer window.
Count Objects in a Pixel Grid via an API
Algorithms & Data Structures · Flood fill through an opaque API — isSameObject is the catch.
Algorithms & Data Structures · Open roads cost 0, closed cost 1 — textbook 0-1 BFS.
Algorithms & Data Structures · A min-heap of (free time, agent) — tuple order breaks the ties.
Algorithms & Data Structures · lower_bound on the prefix itself, then one startswith check.
Stateful Search Autocomplete Session
Algorithms & Data Structures · A typing session over search counts: top three by frequency, then alphabetically.
Algorithms & Data Structures · Parse (count, digit) pairs backward — adjacent runs must differ.
Algorithms & Data Structures · Sort both teams, pair i-th against i-th, and try both orders.
Algorithms & Data Structures · The largest nearest-sensor gap — sort one side, binary search from the other.
Algorithms & Data Structures · Interval greedy: extend coverage with the farthest-reaching clip that still connects.
Shortest Path Around Obstacles
Algorithms & Data Structures · Unit steps on a grid: BFS, and the first arrival is the answer.
Algorithms & Data Structures · Union-Find: an edge whose endpoints already share a root closes a cycle.
Algorithms & Data Structures · Unbounded knapsack in disguise — say that out loud, then roll a 1-D table.
Algorithms & Data Structures · Tokenize into groups of choices, then fold a cartesian product across them.
Algorithms & Data Structures · An undo log per open transaction: rollback replays it, commit hands it to the parent.
Algorithms & Data Structures · Two-pointer scans with no library calls — the point is proving you can.
Algorithms & Data Structures · Injected transport, upserts keyed by id, a dirty set — a small class with senior signals.
Algorithms & Data Structures · A tree of nodes keyed by path segment — the OOD-style prompt where the implementation is the test.
Algorithms & Data Structures · Simulate one unit at a time — left, then right, else stay — and land only on strictly lower ground.
Algorithms & Data Structures · The two-pointer warm-up: one pointer at each end.
Algorithms & Data Structures · Cycle detection dressed up as a scheduling question.
Algorithms & Data Structures · Greedy word wrap inside ASCII borders — never split a word, never start a line with punctuation.
Algorithms & Data Structures · Split first, decode second — the ordering that makes the encoded-ampersand case work.
Algorithms & Data Structures · Case-insensitive, longest match wins, original text preserved — a trie walk from every offset.
Algorithms & Data Structures · Pluggable backoff, a retryable filter, hooks, and an abort signal around one loop.
Algorithms & Data Structures · Consume the oldest stock first and say which lots an order drew from — an implementation prompt with tie-break rules.
Algorithms & Data Structures · Parse, validate, count — and pick the right denominator for the failure rate.
Memory-Bounded Ranked Ballot Counter
Algorithms & Data Structures · Millions of ballots, Borda scoring, and memory that stays O(candidates) — the constraint is the question.
Algorithms & Data Structures · Bucket sort when the multiset fits, a size-N heap when it's a stream — say both.
Algorithms & Data Structures · "Bidirectional and transitive" means connected components — union-find, keyed by the smallest word.
Algorithms & Data Structures · Flood fill from every unvisited land cell — and know when DFS, BFS or union-find fits.
Algorithms & Data Structures · Three linear phases instead of a re-sort: before, overlapping, after.
Algorithms & Data Structures · Separate chaining with a resize at a load-factor threshold — fixed buckets aren't enough.
Algorithms & Data Structures · A heap cannot update a key — push the new entry and discard stale ones at pop time.
Algorithms & Data Structures · One DFS from the base unit multiplies factors down the tree, modulo a prime.
Nth Node at Level L in a 0/1 Tree
Algorithms & Data Structures · Never build the tree — halve recursively, or read the answer off the parity of popcount(n − 1).
Algorithms & Data Structures · A queue of admitted timestamps per key: evict what aged out, admit while under the limit.
Algorithms & Data Structures · Flatten behind hasNext/next with O(depth) memory — and survive [[], [[]], [[], [3]]].
Algorithms & Data Structures · One pass and O(k) memory: item i replaces a random slot with probability k/(i+1).
Algorithms & Data Structures · Two heaps — a max-heap for the lower half, a min-heap for the upper — rebalanced on every add.
Algorithms & Data Structures · Three guarded divisions — and 0 wherever a denominator is 0.
Algorithms & Data Structures · Map, combine, partition, sort, reduce — the three parts a groupby does not have are the whole grade.
Algorithms & Data Structures · Half-open intervals per room, only neighbours can clash — and check-then-book must be one atomic step.
Algorithms & Data Structures · Idempotent writes, a separate read model, and an audit log — all three in one small service.
Algorithms & Data Structures · One pass with a stack of signed terms; the trap is integer division truncating toward zero.
Algorithms & Data Structures · Build in-order and pull values off a forward-only iterator — no middle-finding, no array copy.
Algorithms & Data Structures · Build the trie first and say why: it prunes the DFS the moment a prefix does not exist.
Algorithms & Data Structures · A group dies exactly when it has no adjacent empty point — flood fill each neighbouring enemy group.
Algorithms & Data Structures · TCP is a byte stream: buffer across calls, frame by length prefix, and tell a clean EOF from a truncated message.
Implement a Robust REST Create Method
Algorithms & Data Structures · Authenticate, validate, sanitise — then make POST safe to retry with an Idempotency-Key scoped to the caller.
Algorithms & Data Structures · Sort, then sweep — the pattern behind a dozen calendar problems.
Algorithms & Data Structures · Hash map plus doubly linked list, all operations O(1).
Algorithms & Data Structures · One pass, three sets — and derive the box index out loud instead of asserting it.
Algorithms & Data Structures · Two-colour with BFS from every unvisited node; an odd cycle is the only way to fail.
Algorithms & Data Structures · A 26-count key instead of sorting each word — the only decision in the problem.
Algorithms & Data Structures · BFS, not DFS — shortest path — then mention bidirectional BFS, which roughly square-roots the frontier.
Algorithms & Data Structures · The first character whose second occurrence comes earliest — one pass with a set, emoji included.
Unique Values Across Two Arrays I
Algorithms & Data Structures · Every value once, in first-seen order — a Set keeps insertion order.
Algorithms & Data Structures · Prefix products left to right, suffix products right to left — no division, so zeros need no special case.
Algorithms & Data Structures · PUT, GET and a COUNT of everything under a domain: match on the label boundary, then make COUNT fast with a trie.
Algorithms & Data Structures · A second stack holds the minimum at each depth, so getMin is just its top.
Parse an Integer Without parseInt
Algorithms & Data Structures · Sign, then digits through a lookup table, accumulating n * 10 + d — and NaN for anything else.
Algorithms & Data Structures · Split the nonzero balances into as many zero-sum groups as possible.
Algorithms & Data Structures · Rebuild the itinerary with Hierholzer's walk, then look for a repeat.
Algorithms & Data Structures · BFS from the start: the layer where the last index appears is the answer.
Algorithms & Data Structures · The count served by time T is monotone — binary search T.
Algorithms & Data Structures · Matches are contiguous: lower_bound the prefix, then the prefix bumped by one.
Algorithms & Data Structures · The reverse parse, memoized on (index, previous digit) — count, don't build.
Algorithms & Data Structures · Split, round each value with string arithmetic, join — floats need not apply.
Algorithms & Data Structures · Reassemble the lines, net the balances, then search for the fewest transfers.
Algorithms & Data Structures · Only faced pairs matter: greedily match the smaller team into the larger.
Algorithms & Data Structures · The greedy match, written into two rows with empty slots.
Fewest Towers to Cover Every Crossing
Algorithms & Data Structures · Greedy: place each tower as far right as the leftmost uncovered crossing allows.
Algorithms & Data Structures · One formula for every dimension: the square root of the summed squared differences.
Shortest Path on a Huge Map with A*
Algorithms & Data Structures · BFS's answer, found by expanding cells in order of cost-so-far plus an admissible estimate.
Shortest Path with Terrain Costs
Algorithms & Data Structures · Unequal step costs turn BFS's queue into Dijkstra's priority queue.
Algorithms & Data Structures · A three-line grammar turns nested braces into a tiny recursive-descent parser.
Algorithms & Data Structures · Find the end of each run (or each number), emit, jump.
Algorithms & Data Structures · A read pointer and a write pointer over the same array — write never passes read.
Algorithms & Data Structures · The farthest-reach greedy again, remembering which clip won each round.
Algorithms & Data Structures · Sweep sorted clips tracking the farthest end; a start past it opens a gap.
Algorithms & Data Structures · Start at n components; every successful union merges two into one.
Algorithms & Data Structures · Kahn's algorithm: peel sensors with no pending inputs; leftovers mean a cycle.
Algorithms & Data Structures · The rod-cutting table again, charging for every cut and seeding the whole-rod sale.
Algorithms & Data Structures · Add a piece-count dimension: dp[k][L] builds on dp[k − 1][L − p].
Algorithms & Data Structures · Buckets plus underflow and overflow: O(1) adds, any quantile, error within half a bucket.
Algorithms & Data Structures · Sort by (entity, time), then extend or open one session per entity in a single sweep.
Algorithms & Data Structures · Convert through the base unit — and divide with a modular inverse, since you can't divide mod p.
Algorithms & Data Structures · Store (tokens, last seen) per key and refill lazily on each call — O(1) per key.
Algorithms & Data Structures · Chain iterables behind hasNext/next with a lookahead that skips the empty ones.
Weighted Sampling Without Replacement
Algorithms & Data Structures · A-Res: key each item by random()^(1/weight) and keep the k largest keys.
Stratified Sampling with Largest-Remainder Allocation
Algorithms & Data Structures · Floor each proportional share, give leftovers to the largest remainders, sample within each stratum.
Algorithms & Data Structures · Discount each graded relevance by log2(position + 2), then divide by the ideal ordering's DCG.
Algorithms & Data Structures · Observed agreement corrected for the agreement two annotators would reach by chance.
Algorithms & Data Structures · 1 − C(n − c, k) / C(n, k), computed as a running product so nothing overflows.
Algorithms & Data Structures · Buffer bytes across recv calls, split on newlines, and decode only whole lines.
Algorithms & Data Structures · Where the earliest second occurrence sits — the same set scan, returning an index.
Unique Values Across Two Arrays II
Algorithms & Data Structures · Count every value across both arrays in a Map, then keep the ones counted exactly once.
Unique Values Across Two Arrays III
Algorithms & Data Structures · Objects compare by reference, so deduplicate on a property — the first object with each key wins.
Algorithms & Data Structures · Binary long multiplication: add the doubled multiple for every set bit — and double with +=, not a 32-bit shift.
Algorithms & Data Structures · Each position multiplies its two successors, wrapping around the end with modular indices.
Count Each Character in First-Seen Order
Algorithms & Data Structures · One counting pass into a Map, emitted in insertion order: AAABBAA becomes 5A2B.
Algorithms & Data Structures · A base case at n <= 0 and one recursive call — then say where the call stack runs out.
Algorithms & Data Structures · Binary-search the root in [0, max(1, x)] for a fixed number of rounds — an epsilon loop never ends for large x.
Algorithms & Data Structures · An infinite generator over two BigInts — ordinary numbers lose precision past the 78th term.
Algorithms & Data Structures · Levels from the top down, one character per column — ground, water, or air.
Algorithms & Data Structures · Each sentence wraps at its own width; one box pads every line to the widest.
Algorithms & Data Structures · A rank histogram and two booleans name every category — the ace is the only edge case.
Nearest Bathroom for Every Desk
Algorithms & Data Structures · Seed the queue with every bathroom and expand once — one BFS for the whole floor, not one per desk.
Algorithms & Data Structures · One pass and two remembered indexes — the last person and the last cake seen.
Algorithms & Data Structures · Nearest-cake greedy is wrong; with both lists sorted, an optimal matching never crosses, so a 2-D DP finds it.
Algorithms & Data Structures · Courses run in waves, and a wave takes as long as its slowest course.
Tree Height After Deletions II
Algorithms & Data Structures · Delete exactly the non-root nodes whose own subtree is k or more deep — one post-order pass, no DP.
Algorithms & Data Structures · Topological order with a 26-bit mask per node: inherited = AND of the parents, final = (inherited OR allow) AND NOT disallow.
Algorithms & Data Structures · BFS over an implicit graph, fetching each page exactly once.
Algorithms & Data Structures · Store one predecessor per page, not a path per queue entry, and walk it back from the target.
Algorithms & Data Structures · A BFS that keeps going after the target is gone — and the thread-safety story that comes with it.
Dropped Requests Under Two Rules
Algorithms & Data Structures · One queue of accepted timestamps per rule; dropped requests never enter either.
Algorithms & Data Structures · Per-client (tokens, last seen), a tier config read on every call, and an explicit fallback for clients with no valid tier.
Algorithms & Data Structures · Timestamps arrive in order, so each type's list is already sorted and a count is two binary searches.
Algorithms & Data Structures · One register, a dictionary of recorded bodies, and a mode flag that says whether a line runs or is being stored.
Algorithms & Data Structures · A heap of entries with lazy deletion: a task added twice has two entries, and the stale one is skipped on the way out.
Key-Value Store With Prefix Scan
Algorithms & Data Structures · A hash map for the point operations and a sorted key list for the scan — agree the smallest version, then extend.
Algorithms & Data Structures · Two pointers per run: find where the run ends, reverse it in place, carry on from there.
Algorithms & Data Structures · Turn each match into a clipped line range, merge ranges that touch, and print a separator between the groups left.
Algorithms & Data Structures · Recursive descent with one cursor: a value function that dispatches on the next character, and a parser per kind.
Document Store With Boolean Queries
Algorithms & Data Structures · An inverted index plus a tiny expression parser whose values are sets of document ids.
Does This Connect Four Move Win?
Algorithms & Data Structures · Only the four lines through the last move can have changed, so count outward in each direction from it.
Algorithms & Data Structures · Count the pieces, then check who has a line: X leads by one if X won, counts are equal if O won, and both cannot win.
Top K Search Terms, One Vote per User
Algorithms & Data Structures · Dedupe (user, term) pairs before counting, then sort by count with the term as the tie-break.
Top K Selling Books After Each Sale
Algorithms & Data Structures · Totals in a map; the top K is recomputed from the map on each update, or kept in a bounded structure when K is small and the catalogue huge.
Algorithms & Data Structures · Dutch national flag with three pointers, using only getColor and swap — one pass, no counting.
Algorithms & Data Structures · A course may start once any one prerequisite is done: swap the max for a min and relax in topological order.
Algorithms & Data Structures · A deleted node hands its children to its nearest surviving ancestor, so it simply adds no level.
Most Credits With at Most K Classes
Algorithms & Data Structures · Weighted interval scheduling with a count budget: sort by end, binary-search the compatible predecessor, add a dimension for the cap.
Algorithms & Data Structures · Meeting rooms with stations: a bus is reusable only where it arrived, so keep the idle buses per station.
Filter With a Dynamic Blacklist
Algorithms & Data Structures · Emitted items are final; held items wait in publish order and are re-checked whenever a word is unblocked.
Is the Graph Three-Colourable?
Algorithms & Data Structures · Backtracking over the vertices: try each colour not used by a coloured neighbour, undo on failure.
Fewest Coins When Change Is Given
Algorithms & Data Structures · Overpaying can save coins: minimise coins handed over plus coins handed back, over every payment up to one large coin above the price.
Document Coverage: The Shortest Window
Algorithms & Data Structures · Minimum window over tokens: expand until every term is covered, shrink while it stays covered, keep the shortest.
Pick the Query Type That Maximises Revenue
Algorithms & Data Structures · Committing to one type, you run it floor(k / duration) times; score every type and keep the best, earliest on ties.
Reach a Target With +2, Double and Halve
Algorithms & Data Structures · Any sequence counts, so think constructively: +2 keeps parity, doubling then +2s then halving shifts it, and halving is how you get smaller.
Drop and Remove Runs in a Grid
Algorithms & Data Structures · Mark every horizontal and vertical run of three or more, clear them all at once, let columns fall, and repeat until nothing is marked.
Algorithms & Data Structures · Kahn's queue over course objects; a failed attempt goes to the back of the queue and its dependants stay locked until it passes.
Algorithms & Data Structures · A failure is explained if something it depends on, transitively, failed first; the unexplained failures are the root causes.
Algorithms & Data Structures · A recursive-descent parser: a command's operand is either an integer or a parenthesised sub-program evaluated from zero.
Count the Nodes of a Tree by Messages
Algorithms & Data Structures · A node asks every neighbour except the one that asked it, sums the replies plus one, and remembers answers so duplicates are harmless.
Algorithms & Data Structures · Pre-order with explicit end-of-word marks and parentheses around children; parsing it back is a recursive descent.
Pre-Order Traversal Skipping Marked Nodes
Algorithms & Data Structures · A pre-order walk with a stack; a marked node is dropped before its children are pushed, so its whole subtree disappears.
Delete a Node From a Forest Stored as a Parent Array
Algorithms & Data Structures · Children of the deleted node are re-parented to its parent; a deleted root's children become roots.
Rewrite Two Complete Trees With Subtree Sums
Algorithms & Data Structures · In array form the children of i are 2i + 1 and 2i + 2, so merge by index and accumulate sums from the last index down.
Algorithms & Data Structures · A queue with an index pointer, a visited set marked on enqueue, neighbours in the order given.
Algorithms & Data Structures · Split in half, sort each half, merge with two indices — stable, O(n log n), and the merge is the whole interview.
Algorithms & Data Structures · A priority queue of tentative distances; a node's distance is final the first time it is popped.
Asked on LeetCode
3,115 questions · all time
- LRU CachemediumHash TableLinked ListDesignDoubly-Linked List47 companies
- Merge IntervalsmediumArraySortingQuicksort45 companies
- Number of IslandsmediumArrayDepth-First SearchBreadth-First SearchUnion-Find+136 companies
- Two SumeasyArrayHash Table30 companies
- Merge k Sorted ListshardLinked ListDivide and ConquerHeap (Priority Queue)Merge Sort+129 companies
- Trapping Rain WaterhardArrayTwo PointersDynamic ProgrammingStack+128 companies
- Valid ParentheseseasyStringStackBracket Sequences28 companies
- Group AnagramsmediumArrayHash TableStringSorting27 companies
- Text JustificationhardArrayStringSimulation26 companies
- Longest Substring Without Repeating CharactersmediumHash TableStringSliding Window26 companies
- Find Median from Data StreamhardTwo PointersDesignSortingHeap (Priority Queue)+125 companies
- Time Based Key-Value StoremediumHash TableStringBinary SearchDesign25 companies
- Top K Frequent ElementsmediumArrayHash TableDivide and ConquerSorting+425 companies
- Rotting OrangesmediumArrayBreadth-First SearchMatrix25 companies
- Best Time to Buy and Sell StockeasyArrayDynamic Programming24 companies
- Insert Delete GetRandom O(1)mediumArrayHash TableMathDesign+124 companies
- Course Schedule IImediumDepth-First SearchBreadth-First SearchGraph TheoryTopological Sort24 companies
- Meeting Rooms IImediumArrayTwo PointersGreedySorting+223 companies
- Course SchedulemediumDepth-First SearchBreadth-First SearchGraph TheoryTopological Sort+123 companies
- Word LadderhardHash TableStringBreadth-First SearchBidirectional Search22 companies
- Longest Palindromic SubstringmediumTwo PointersStringDynamic ProgrammingManacher21 companies
- Koko Eating BananasmediumArrayBinary Search21 companies
- Median of Two Sorted ArrayshardArrayBinary SearchDivide and Conquer20 companies
- String CompressionmediumTwo PointersString20 companies
- Minimum Window SubstringhardHash TableStringSliding Window20 companies
- Spiral MatrixmediumArrayMatrixSimulation20 companies
- Search in Rotated Sorted ArraymediumArrayBinary Search20 companies
- House RobbermediumArrayDynamic Programming20 companies
- Basic Calculator IImediumMathStringStack19 companies
- Sliding Window MaximumhardArrayQueueSliding WindowHeap (Priority Queue)+219 companies
- Word SearchmediumArrayStringBacktrackingDepth-First Search+119 companies
- Longest Consecutive SequencemediumArrayHash TableUnion-Find19 companies
- Add Two NumbersmediumLinked ListMathRecursion18 companies
- Design Circular QueuemediumArrayLinked ListDesignQueue18 companies
- Design Hit CountermediumArrayBinary SearchDesignQueue+118 companies
- Maximal SquaremediumArrayDynamic ProgrammingMatrix18 companies
- Maximum SubarraymediumArrayDivide and ConquerDynamic Programming18 companies
- LFU CachehardHash TableLinked ListDesignDoubly-Linked List18 companies
- Kth Largest Element in an ArraymediumArrayDivide and ConquerSortingHeap (Priority Queue)+118 companies
- Asteroid CollisionmediumArrayStackSimulation17 companies
- Basic CalculatorhardMathStringStackRecursion17 companies
- Decode StringmediumStringStackRecursion17 companies
- Find First and Last Position of Element in Sorted ArraymediumArrayBinary Search17 companies
- Implement Trie (Prefix Tree)mediumHash TableStringDesignTrie17 companies
- Rotate ImagemediumArrayMathMatrix17 companies
- Product of Array Except SelfmediumArrayPrefix Sum17 companies
- Coin ChangemediumArrayDynamic ProgrammingBreadth-First SearchKnapsack Problem+117 companies
- 3SummediumArrayTwo PointersSorting17 companies
- Merge Two Sorted ListseasyLinked ListRecursion17 companies
- Random Pick with WeightmediumArrayMathBinary SearchPrefix Sum+116 companies
Listings only — titles, difficulty, and tags link out to LeetCode. Imported from the leetcode-company-wise-problems snapshot dated 1 June 2025. Frequency is that dataset's own relative score within a company and time range.