Top 50 Coding Interview Questions with Answers (2026): Fresher to FAANG-Ready

💡 Why Interviewers Ask This: The most famous warm-up in tech. Tests your ability to trade space for time using hash maps — the most important pattern in all of coding interviews.

Use the Two Pointers technique. Place one pointer at the start and one at the end, swap the characters, and move both pointers inward until they meet. Time: O(n) | Space: O(1) — an in-place operation.

💡 Why Interviewers Ask This: Establishes baseline understanding of in-place array manipulation and the two-pointer mental model used across dozens of harder problems.

Sanitize the string (remove non-alphanumeric, convert to lowercase). Apply Two Pointers (start and end), comparing characters inward. If all match, it is a palindrome. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Tests string parsing, edge-case handling (empty strings, spaces, punctuation), and the two-pointer technique simultaneously.

Kadane's Algorithm: iterate through, tracking current_sum = max(num, current_sum + num) and max_sum = max(max_sum, current_sum). At each position, choose: extend the previous subarray or start fresh with the current element. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: The ultimate DP introduction — tests ability to track local vs. global maximum, the backbone of dozens of DP problems.

Iterate from 1 to n using the Modulo Operator (%). Check i % 15 == 0 first (FizzBuzz), then i % 3 (Fizz), then i % 5 (Buzz), else print the number. Order of checks is critical — 15 must precede 3 and 5. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: A classic filter — tests control flow, loop structure, and operator precedence. Many candidates get the check order wrong.

Single-pass Greedy: track min_price = ∞ and max_profit = 0. For each price, update min_price if lower, then update max_profit if price − min_price is greater. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Tests greedy single-pass and tracking historical minimum state without nested loops.

Insert all elements into a Hash Set. If set size < array size (or an insertion collision occurs), a duplicate exists. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: Tests whether you immediately recognise Set properties (unique values, O(1) lookup) to solve duplication without sorting.

Optimal: Frequency Counter — an array of 26 for lowercase letters. Increment for string s, decrement for string t. If all counts are zero, it is an anagram. Time: O(n) | Space: O(1) (constant 26-character alphabet). Sorting is O(n log n) — slower.

💡 Why Interviewers Ask This: Evaluates frequency counting as a substitute for expensive sorting and understanding of the ASCII character set.

Sort intervals by start value in O(n log n). Then iterate: if current interval's start ≤ previous end, merge by updating end to max(prev.end, curr.end). Otherwise add current to result. Time: O(n log n) | Space: O(n).

💡 Why Interviewers Ask This: Practical for calendar/scheduling — tests sorting custom objects and reducing overlapping logic to a clean linear scan.

Sort the array. Fix pointer i, then use Two Pointers (left = i+1, right = end) for pairs summing to -nums[i]. If sum < 0: move left right; if > 0: move right left. Skip duplicate values. Time: O(n²) | Space: O(1).

💡 Why Interviewers Ask This: Step up from Two Sum — tests combining sorting with multi-pointer traversal, reducing O(n³) to O(n²).

Without division in O(n): forward pass to fill output[i] = product of all elements left of i. Backward pass: multiply each output[i] by a running suffix product of elements to its right. Time: O(n) | Space: O(1) (output excluded).

💡 Why Interviewers Ask This: A genius-level logic test — forces thinking about prefix and suffix products without the easy division shortcut.

Two approaches: (1) Gauss's Formula: expected sum = n(n+1)/2 minus actual sum = missing number. (2) XOR Bitwise: XOR all indices 0..n with all array values — duplicates cancel out, leaving the missing number. Both: Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Tests both mathematical optimization and bit manipulation — two entirely different O(1) space solutions to the same problem.

Use Sliding Window with a Hash Set or Hash Map. Expand by moving the right pointer. On duplicate, shrink from the left until duplicate is removed. Track maximum window size seen. Time: O(n) | Space: O(min(n,m)) where m = alphabet size.

💡 Why Interviewers Ask This: The definitive Sliding Window question — tests dynamic window resizing under constraints, a pattern used in dozens of substring problems.

Use Two Pointers (start and end). Area = width × min(height[left], height[right]). Always move the pointer pointing to the shorter line inward — moving the taller one can only decrease area. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Classic greedy optimization — proves you can narrow a search space from O(n²) to O(n) with a justified greedy pointer movement.

The optimal in-place solution uses the Array Reversal Technique in 3 steps: (1) Reverse entire array. (2) Reverse first k elements. (3) Reverse remaining n−k elements. Time: O(n) | Space: O(1) — no secondary array needed.

💡 Why Interviewers Ask This: Tests knowledge of clever algorithmic tricks to manipulate array indices without allocating extra space.

Use three pointers: prev = null, curr = head, next_node. Each step: save next_node = curr.next, reverse with curr.next = prev, advance both. Return prev as new head. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Most fundamental linked list question — tests safe pointer manipulation without losing reference to the rest of the list.

Use Floyd's Tortoise and Hare Algorithm. Slow pointer moves 1 step; fast pointer moves 2 steps. If they ever meet, a cycle exists. If fast reaches null — no cycle. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Tests knowledge of a famous named algorithm and detecting infinite loops in O(1) space, superior to the O(n) Hash Set approach.

Create a Dummy Node as the merged list's head. Traverse both lists simultaneously, always attaching the node with the smaller value and advancing that list's pointer. Attach any remaining non-null list at the end. Time: O(m+n) | Space: O(1).

💡 Why Interviewers Ask This: Tests the Dummy Node pattern to handle edge cases (empty lists, differing lengths) without special-casing the head pointer.

Use Two Pointers with a gap from a dummy head. Advance the fast pointer n+1 steps. Then move both together until fast reaches null. Slow pointer is now just before the target — set slow.next = slow.next.next. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Tests locating a position from the end of a one-directional list in a single pass, without knowing its length.

Use Fast and Slow Pointers. Slow moves 1 node; fast moves 2. When fast reaches the end, slow is exactly at the middle node. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: Another application of Tortoise and Hare — proves you can find midpoints without a preliminary counting pass, a prerequisite for Merge Sort on linked lists.

Calculate lengths of both lists. Advance the head of the longer list by the absolute difference in lengths. Then traverse both simultaneously; the node where pointers are equal (same memory reference) is the intersection. Time: O(m+n) | Space: O(1).

💡 Why Interviewers Ask This: Tests understanding that “intersection” means the exact same node reference in memory, not just equal values — a subtle but critical distinction.

Use a Stack (LIFO). Push open brackets. On a closing bracket, pop the top and verify it's the matching opener. Return true only if the stack is empty at the end. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: The quintessential Stack problem — how compilers parse and validate syntax for nested structures.

Use Two Stacks: input_stack and output_stack. Push to input always. For peek/pop: if output is empty, pour all of input into output (reversing to FIFO). Amortized Time: O(1) | Space: O(n).

💡 Why Interviewers Ask This: Tests deep understanding of data structure internals — simulating FIFO using LIFO mechanics.

Maintain a secondary min-stack alongside the main stack. On push, also push to min-stack if new value ≤ current minimum. On pop, if popped value equals min-stack's top, pop both. All operations including getMin() are O(1) Time.

💡 Why Interviewers Ask This: Micro systems design — trading space for constant-time minimum retrieval.

Use a Stack. Iterate tokens: if a number, push it. If an operator, pop top two values, apply the operator, push back the result. Final stack item is the answer. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: Evaluates ability to parse postfix notation — the core of calculator logic and abstract syntax tree evaluation.

Use a Monotonic Decreasing Stack of indices. For each temperature, while the stack is non-empty and the current temp is warmer than the temp at the top index, pop and record the index difference as the answer. Push current index. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: Introduces the Monotonic Stack pattern — the optimal O(n) way to solve “Next Greater Element” class problems.

Combine a Hash Map (O(1) lookup) and a Doubly Linked List (O(1) insert/delete). The map stores key → list node. On access/insert, move the node to the head (most recently used). On capacity breach, remove the tail (least recently used) and its map entry. All operations: O(1) Time | O(capacity) Space.

💡 Why Interviewers Ask This: The ultimate intermediate design question — tests combining two standard data structures to build a highly efficient caching component used in operating systems and CPU hardware.

Use a Hash Map mapping original nodes to their newly created clones. Pass 1: create all clone nodes and populate the map. Pass 2: use the map to assign clone.next and clone.random by looking up the mapped equivalents. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: Tests ability to perform deep copies on complex structures containing randomised or cyclic references — a common real-world serialisation problem.

Use DFS (recursion). Base case: null → return 0. Recursive: return 1 + max(depth(left), depth(right)). Time: O(n) | Space: O(h) where h = tree height (O(log n) balanced, O(n) worst case).

💡 Why Interviewers Ask This: The absolute baseline test for recursion and tree data structures. Every harder tree problem builds on this pattern.

Use DFS (recursion): for every node, swap its left and right children, then recursively invert both subtrees. Alternatively use BFS (queue): swap children at each dequeued node. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: Famously viral as the “Homebrew creator question.” Tests binary tree manipulation and recursive state management.

Traverse both trees simultaneously via recursion. Base cases: both null → true; one null or values differ → false. Otherwise: return sameTree(p.left, q.left) && sameTree(p.right, q.right). Time: O(n) | Space: O(h).

💡 Why Interviewers Ask This: Evaluates ability to traverse two distinct data structures in tandem and handle all null-combination edge cases correctly.

Exploit BST structure: if both p and q are less than root → go left. If both are greater → go right. The moment paths diverge (root is between them), the current node is the LCA. Time: O(log n) avg | Space: O(1).

💡 Why Interviewers Ask This: Tests whether you truly understand the BST rule — left < root < right — and can exploit it to eliminate entire subtrees.

Use BFS with a Queue. Enqueue root. Each iteration: determine queue size (= nodes in this level), process exactly that many, enqueue non-null children. Collect each level's values into a sub-list. Time: O(n) | Space: O(n).

💡 Why Interviewers Ask This: Verifies you understand horizontal (BFS) vs. vertical (DFS) traversal and can use a queue to track level boundaries.

Use DFS with boundary propagation: pass (min, max) range to each node. Root starts with (−∞, +∞). Moving left sets the max limit; moving right sets the min limit. Any violation → false. Time: O(n) | Space: O(h).

💡 Why Interviewers Ask This: Catches candidates who only check immediate parent-child, missing the BST rule that all descendants must be within valid bounds.

Treat the 2D grid as a graph. Iterate every cell. When land ('1') is found, increment counter and use DFS or BFS to mark all adjacent connected land as '0' (visited). Time: O(m×n) | Space: O(m×n).

💡 Why Interviewers Ask This: The most common matrix graph traversal — finding connected components in an unweighted grid graph.

Use DFS or BFS with a Hash Map mapping original nodes to their clones. Before recursing into neighbors, check if the clone already exists in the map — this prevents infinite loops from cyclic edges. Time: O(V+E) | Space: O(V).

💡 Why Interviewers Ask This: Like copying a list with random pointers — tests handling cyclic references in deep copy operations.

Model prerequisites as a Directed Graph and detect cycles using: (1) Topological Sort (Kahn's BFS) — track in-degrees; if all nodes are processed, no cycle. (2) DFS with three states (unvisited / visiting / visited). Time: O(V+E).

💡 Why Interviewers Ask This: Tests translating real-world dependency problems into Directed Acyclic Graph (DAG) cycle detection.

Each word is a graph node; edges connect words differing by one letter. Use BFS to find the shortest transformation path — BFS guarantees the shortest path in an unweighted graph; DFS only finds a path, not necessarily the shortest. Time: O(M² × N).

💡 Why Interviewers Ask This: Tests algorithm selection instinct — the ability to immediately recognise BFS as the correct choice for shortest-path in an unweighted graph.

Design a TrieNode with a children map (or 26-char array) and boolean is_end_of_word. For insert and search: traverse character by character, creating nodes as needed. startsWith: same traversal without requiring end-of-word. Time: O(m) per operation.

💡 Why Interviewers Ask This: Tries power real-world autocomplete and spell-check. Tests advanced string data structure knowledge beyond hash maps.

Use In-Order Traversal (Left → Root → Right) which naturally visits BST nodes in ascending sorted order. Maintain a counter; when it reaches k, return the current node's value. Time: O(n) | Space: O(h).

💡 Why Interviewers Ask This: Tests whether you know in-order traversal of a BST automatically yields a sorted sequence — a one-insight solution.

This is the Fibonacci Sequence. To reach step n, you came from n−1 or n−2. Use Bottom-Up DP with two variables. Time: O(n) | Space: O(1).

💡 Why Interviewers Ask This: The easiest gateway to DP — tests recognising overlapping subproblems and avoiding exponential brute-force recursion.

Classic Unbounded Knapsack DP. Create dp[0..amount] = Infinity, dp[0] = 0. For each amount i, try every coin: dp[i] = min(dp[i], 1 + dp[i−coin]). Return dp[amount] or −1. Time: O(amount × coins) | Space: O(amount).

💡 Why Interviewers Ask This: Tests establishing a DP recurrence relation and combinatorial optimization with unbounded item selection.

💡 Why Interviewers Ask This: Differentiates senior engineers — the O(n log n) binary search optimization proves true algorithmic mastery.

Build a 2D DP table of size (m+1)×(n+1). If chars match: dp[i][j] = 1 + dp[i−1][j−1]. If not: dp[i][j] = max(dp[i−1][j], dp[i][j−1]). Answer is dp[m][n]. Time: O(m×n) | Space: O(m×n).

💡 Why Interviewers Ask This: The definitive 2D DP question — powers Git's diff command and DNA sequence alignment algorithms.

Use 1D DP. Boolean array dp[0..n]: dp[i] is true if the first i chars can be segmented. For each i, check all substrings s[j..i] where dp[j] is true and s[j..i] is in the dictionary. Time: O(n²) | Space: O(n).

💡 Why Interviewers Ask This: Tests DP partitioning to avoid re-evaluating identical substrings — a pure memoization insight.

Use a Min-Heap (Priority Queue). Insert the head of all K lists. Repeatedly extract the minimum, attach to result, push that node's next into the heap. Time: O(N log K) | Space: O(K).

💡 Why Interviewers Ask This: Tests Priority Queue mastery — the exact algorithm behind external sorting and large-scale database merges.

💡 Why Interviewers Ask This: The Bucket Sort approach proves you understand index-mapping for linear time — a non-obvious optimization over sorting.

Use Two Pointers with left_max and right_max. Move the pointer with smaller height inward. Water trapped = max_height − current_height. Time: O(n) | Space: O(1) — superior to the O(n) space prefix/suffix array approach.

💡 Why Interviewers Ask This: Notoriously hard logic puzzle — tests spatial visualization and O(1) space optimization via two-pointer convergence.

Maintain Two Heaps: Max-Heap for the lower half, Min-Heap for the upper half. Re-balance after each insertion so heaps are equal-sized (or max-heap is 1 larger). Median = top of larger heap, or average of both tops. Time: O(log n) per insert | O(1) getMedian.

💡 Why Interviewers Ask This: Top-tier design question — tests maintaining a sorted property dynamically on an infinite live stream.

Use a Monotonic Deque (double-ended queue) of indices. As window slides: remove indices from the left that fall outside the window; remove indices from the right whose values ≤ current element (keeping deque strictly decreasing). Front always holds the window maximum. Time: O(n) | Space: O(k).

💡 Why Interviewers Ask This: One of the hardest array questions — tests mastery of the Monotonic Deque to achieve O(n) on a complex sliding-window maximum.