Coding questions.

79 coding questions from the bank, ready to practice out loud.

All 79 questions

Minimum meeting rooms requiredWrite a function that takes a list of meeting intervals and returns the minimum number of rooms required to schedule all of them.Data StructuresMid–senior

Longest substring without repeatsGiven a string, return the length of the longest substring without repeating characters. Your function should run in linear time.AlgorithmsEntry–mid

Least-recently-used cache implementationImplement a least-recently-used cache with constant-time get and put. The capacity is fixed at construction.Data StructuresMid–senior

Running median from integer streamWrite a function that takes a stream of integers and returns the running median after each insert.System ReasoningSenior–staff+

Counting distinct islands in gridGiven a 2D grid of 1s and 0s representing land and water, return the number of distinct islands. Two cells are part of the same island if they share an edge.AlgorithmsEntry–mid

Pairs summing to targetYou have an array of integers and need to find every pair that sums to a given target. Optimize for time and call out the trade-off you're making.OptimizationEntry–mid

Binary tree serializationImplement a function that serializes and deserializes a binary tree. Pick the format and explain why it works for your traversal.Data StructuresMid–senior

Grouping anagrams togetherGiven a list of words, group anagrams together. Each group is a list of words; order within groups doesn't matter.AlgorithmsEntry–mid

Rate limiter for multiple usersDesign a rate limiter that allows N requests per user per minute. Implement the check function and discuss how you'd handle a million users.System ReasoningMid–senior

Fixing stack overflow in recursionHere's a recursive function that's supposed to flatten a nested list of integers but is throwing stack overflow on large inputs. How would you fix it?DebuggingMid–senior

Maximum profit two transactionsGiven an array of stock prices indexed by day, return the maximum profit from at most two non-overlapping buy-sell transactions.AlgorithmsMid–senior

Trie with prefix searchImplement a trie that supports insert, search, and prefix-search of words. Then write a function that returns all words sharing a given prefix.Data StructuresMid–senior

Top K IPs from logsWrite a function that processes a log file and returns the top K most frequent IP addresses. Assume the file is too large to fit in memory.System ReasoningSenior–staff+

Right side view of treeGiven a binary tree, return the values you'd see standing on the right side. Each level contributes at most one value.AlgorithmsEntry–mid

Optimizing kth largest element searchYou have a function that finds the kth largest element by sorting. The interviewer asks you to do better — what's your move and what's the worst case?OptimizationMid–senior

Implementing a queue with stacksImplement a queue using only stacks. Both enqueue and dequeue should be amortized O(1).Data StructuresEntry–mid

Detecting cycles in directed graphsGiven a directed graph as an adjacency list, detect whether it has a cycle. Return true or false.AlgorithmsMid–senior

Thread-safe username availability checkerImplement a function that returns the next available username given a desired one, appending numbers if needed. Multiple workers will call this concurrently — make it safe.System ReasoningSenior–staff+

Reversing a 32-bit signed integerGiven a 32-bit signed integer, reverse its digits and return the result. If the reversed integer overflows, return zero.AlgorithmsEntry–mid

Implementing a min-stackImplement a min-stack that supports push, pop, and an O(1) operation that returns the current minimum.Data StructuresEntry–mid

Kth most frequent wordGiven a long string of words separated by spaces, return the kth most frequent word. If multiple words tie, return the alphabetically smallest.OptimizationMid–senior

One edit distance checkImplement a function that returns whether two strings are one edit away — insert, delete, or replace one character.AlgorithmsEntry–mid

Memoizing with a freshness windowYou're given a function that fetches a user's profile from a remote service. Implement a memoized version that respects a 5-minute freshness window.System ReasoningMid–senior

Triplets summing to zeroGiven an array, return all distinct triplets whose values sum to zero. The result should not contain duplicate triplets.AlgorithmsMid–senior

Range query data structureDesign a class that stores a stream of integers and lets callers ask for the number of values within a given range. Inserts and range queries should both be fast.Data StructuresSenior–staff+

Longest increasing path in gridYou have an N-by-N grid. Write a function that returns the longest increasing path you can walk through adjacent cells in any direction.OptimizationSenior–staff+

Merge sorted linked lists bugHere's a function that's supposed to merge two sorted linked lists into one. It works on most inputs but returns the wrong result when one list is empty. Walk me through your fix.DebuggingEntry–mid

Palindrome linked list checkWrite a function that returns whether a singly linked list is a palindrome. Optimize for space.AlgorithmsMid–senior

Binary search tree in-order iteratorImplement a function that takes the root of a binary search tree and returns an iterator that yields values in order. The iterator should use O(h) space.Data StructuresSenior–staff+

Words from one keyboard rowGiven a list of words, find all words that can be typed using only one row of a QWERTY keyboard. Define the rows yourself.AlgorithmsEntry–mid

Parsing ISO 8601 duration stringsWrite a function that parses an ISO 8601 duration string like 'PT1H30M' and returns total minutes. Handle missing components and call out malformed inputs.System ReasoningEntry–mid

Intersection of large setsYou need to find whether two sets of integers have any element in common. The sets can be very large. Walk me through your choice of approach.OptimizationEntry–mid

Counting subarrays with target sumGiven an array of integers and an integer k, return the number of contiguous subarrays whose sum equals k.AlgorithmsMid–senior

Clustering strings by edit distanceImplement a function that takes a list of strings and groups them into clusters where strings in the same cluster differ by at most one character.Data StructuresSenior–staff+

Finding nested keys by predicateWrite a function that takes a JSON-like nested structure and returns all key paths whose value matches a predicate. Don't assume a fixed depth.System ReasoningMid–senior

Merging overlapping intervalsGiven a list of intervals, merge all overlapping ones and return the result sorted by start time.AlgorithmsEntry–mid

Hash table with open addressingImplement a hash table from scratch with open addressing. Support insert, lookup, and delete with linear probing.Data StructuresSenior–staff+

Concurrent API calls with limitYou have a method that calls a third-party API for each item in a list. Rewrite it so that calls run concurrently with a maximum of N in flight at any time.OptimizationMid–senior

Validating nested parenthesesGiven a string of parentheses, brackets, and braces, return true if they're correctly nested and matched.AlgorithmsEntry–mid

Exponential backoff with jitterImplement an exponential backoff helper for an HTTP client. It should accept a callable, a max-retry count, and a base delay, and add jitter.System ReasoningMid–senior

Maximum in sliding windowGiven an array of integers and a window size k, return the maximum of every contiguous window in a single pass. Sorting each window is too slow — what structure gets you O(n) total?AlgorithmsMid–senior

Task scheduling with dependenciesYou're given build tasks and their dependencies. Tasks with no unmet dependencies can run in parallel. Write a function that returns the minimum number of rounds needed to finish everything, or reports that it's impossible.AlgorithmsMid–senior

In-memory store with nested transactionsImplement an in-memory key-value store that supports get, set, and nested transactions: begin, commit, and rollback. A rollback undoes everything since the matching begin.Data StructuresSenior–staff+

Merging K sorted iteratorsYou have K sorted iterators that are too large to materialize. Write a function that yields all their elements in sorted order, doing O(log K) work per element.Data StructuresMid–senior

Consistent hashing ring implementationImplement a consistent-hashing ring: add a node, remove a node, and look up which node owns a key. Show why only a small fraction of keys move when membership changes.System ReasoningSenior–staff+

Debounce wrapper for expensive functionsWrite a debounce wrapper: given an expensive function and a delay, return a version that only fires after calls stop arriving for that delay. What happens to the arguments and return value of the suppressed calls?System ReasoningMid–senior

Minimum capacity for job deadlinesYou must process N jobs of known sizes within D days, doing jobs in order, one batch per day. Write a function that finds the minimum daily capacity that makes the deadline. What's the search space?OptimizationMid–senior

Diffing nested configuration objectsWrite a function that diffs two nested configuration objects and returns the minimal change set: paths added, removed, and changed. Arrays and scalars can appear at any depth.System ReasoningMid–senior

Binary search infinite loop bugsA binary search implementation returns correct answers on most inputs but loops forever on a few. Without seeing the code, what are the classic mistakes that cause this, and how would you fix the loop invariant?DebuggingMid–senior

Safe list mutation during iterationA loop removes items from a list while iterating over it, and users report that some items survive the cleanup. Explain why elements get skipped and give two safe ways to write it.DebuggingEntry–mid

Moving zeros to array endGiven an array of integers, move every zero to the end while keeping the relative order of the non-zero elements. Do it in place with O(1) extra space.AlgorithmsEntry–mid

Streaming average of kDesign a class that receives a stream of numbers and returns the average of the last k values after each insert. What do you store, and what's the cost per insert?Data StructuresEntry–mid

Detecting string rotationGiven two strings, determine whether one is a rotation of the other — for example, 'erbottlewat' is a rotation of 'waterbottle'. Aim for a solution that makes only one containment check.AlgorithmsEntry–mid

Testing a URL slug functionA coding assistant drafted a function that slugifies arbitrary titles into URL-safe strings, and all the tests it wrote for itself pass. What properties and adversarial inputs would you test before trusting it in production?TestingMid–senior

Searching rotated sorted arrayWrite a function that takes a sorted array rotated at an unknown pivot and a target value, then returns the index of the target in O(log n) time. If the target doesn't exist, return -1.AlgorithmsEntry–mid

Circular buffer with wraparoundImplement a circular buffer with fixed capacity that supports enqueue, dequeue, and isFull operations in constant time. Explain how you handle wraparound and discuss thread-safety considerations.Data StructuresEntry–mid

Cycle detection in directed graphsGiven a directed graph represented as an adjacency list, detect if there's a cycle. Optimize for graphs with millions of nodes and explain your space-time trade-offs.AlgorithmsMid–senior

Optimizing memoized FibonacciYou're given a function that calculates Fibonacci numbers recursively with memoization, but profiling shows it's still slow for n > 10,000. Identify the bottleneck and propose two different optimizations.DebuggingMid–senior

O(1) insert, delete, and randomDesign a data structure that supports insert, delete, and getRandom in average O(1) time. All elements have equal probability of being returned by getRandom.Data StructuresMid–senior

Merging K sorted linked listsImplement a function that merges K sorted linked lists into one sorted list. Analyze the time complexity of your approach and explain when you'd choose an alternative algorithm.AlgorithmsMid–senior

Validating binary search treesWrite a function that takes a binary tree and returns true if it's a valid binary search tree. Consider edge cases including duplicate values, integer overflow, and the definition you're using for validity.Data StructuresEntry–mid

Testing financial transaction reconciliationYou have a distributed system that processes financial transactions. Write a test plan for a function that reconciles accounts across three data centers. What test cases matter most and why?TestingSenior–staff+

Maximum subarray with one removalGiven an array of integers, find the maximum sum of any contiguous subarray. Then extend your solution to handle the case where you can remove at most one element from the chosen subarray.AlgorithmsMid–senior

Min-heap with decreaseKey operationImplement a min-heap that supports standard operations plus a decreaseKey function in O(log n) time. Explain where this data structure is essential and why a balanced BST wouldn't suffice.Data StructuresMid–senior

Autocomplete system with caching strategyDesign an autocomplete system that returns the top 3 most frequent search queries matching a prefix. Optimize for read-heavy workloads with millions of queries per second and explain your caching strategy.System ReasoningSenior–staff+

Word frequency memory leakYou're reviewing code that uses a hash table to count word frequencies in a document, but it's running out of memory on production logs. Walk through your debugging process and propose fixes.DebuggingMid–senior

String subsequence matching and optimizationWrite a function that determines if one string is a subsequence of another. Then optimize it to handle a stream of queries against a single, fixed parent string.OptimizationMid–senior

Thread-safe blocking queue implementationImplement a thread-safe blocking queue with a maximum capacity. Support put, take, and tryTake with timeout. Discuss your choice of synchronization primitives and potential deadlock scenarios.Data StructuresSenior–staff+

Searching sorted matrix efficientlyGiven a matrix where each row and column is sorted in ascending order, write a function to search for a target value in O(m + n) time. Explain why binary search on each row isn't optimal here.AlgorithmsEntry–mid

URL shortener design and scalingDesign a URL shortener that generates unique short codes and redirects users. Handle collisions, discuss how you'd scale to a billion URLs, and explain your choice of character set for codes.System ReasoningMid–senior

Testing mathematical expression parserWrite unit tests for a function that parses and evaluates mathematical expressions with parentheses, addition, subtraction, multiplication, and division. What edge cases would you prioritize?TestingMid–senior

Longest palindromic substring approachesImplement a function that finds the longest palindromic substring in a given string. Compare at least two approaches with different time-space trade-offs and explain when you'd use each.OptimizationMid–senior

Deep-copying tree with random pointersYou're given a binary tree where each node has a random pointer that may point to any node in the tree or null. Write a function to deep-copy the tree, preserving all random pointers correctly.Data StructuresSenior–staff+

Batched logging with flush policiesDesign a logging library that batches writes to disk to minimize I/O. Implement flush policies based on time, buffer size, and log level. Discuss how you'd test durability guarantees without actual disk access.System ReasoningSenior–staff+

Finding common free time slotsGiven a list of time intervals representing busy periods for N people, find all time slots where everyone is free for at least K minutes. Optimize for the common case where most intervals don't overlap.AlgorithmsMid–senior

Debugging and optimizing edit distanceHere's a function that computes edit distance between two strings using dynamic programming, but it's failing on strings longer than 10,000 characters. Debug it and propose both a memory optimization and a way to handle even larger inputs.DebuggingSenior–staff+

Consistent hashing with virtual nodesImplement a consistent hashing ring for distributing cache keys across N servers. Support adding and removing servers with minimal key reassignment. Explain how virtual nodes improve balance.Data StructuresSenior–staff+

Three-sum zero tripletsWrite a function that takes an array of integers and returns all unique triplets that sum to zero. Optimize to avoid duplicate triplets and analyze how your approach scales with input size.AlgorithmsMid–senior

Testing payment API idempotencyDesign a test harness for a payment processing API that must validate idempotency, handle retries correctly, and maintain exactly-once semantics. What failure modes would you simulate and how?TestingSenior–staff+