106 articles
Two Sum is the #1 most-asked interview problem at Google, Amazon, and Meta — confirmed in over 170 interviews at 70 companies. But it is not about the solution. It is about showing you can trade space for time, recognize the hashmap complement pattern, and handle every follow-up a senior engineer can throw at you.
Learn why LeetCode 121 is a FAANG staple — not because it is hard, but because of what it reveals about your thinking. Master the running-minimum insight, avoid the global min/max trap, and understand all five stock variants from 121 to 309.
LC 217 looks trivially easy — but FAANG interviewers use it to probe your hashset vs sorting instincts, your ability to articulate space-time trade-offs, and whether you can spot the follow-up traps in LC 219 and LC 220. Full solutions in Python and JavaScript with deep explanation.
Most explanations of Kadane's Algorithm get it subtly wrong. Learn the correct mental model, the critical reset-to-0 bug that trips everyone up, a full visual dry run, divide-and-conquer alternative, and every FAANG follow-up question with approach hints.
LeetCode 283 is the gateway to the two-pointer partition pattern used across dozens of harder problems. Learn why it appears in almost every Microsoft and Amazon phone screen, master the write-pointer mental model with a step-by-step dry run, and understand when to swap vs. overwrite — with Python and JavaScript solutions fully annotated.
LeetCode 66 looks trivial until you hit [9,9,9]. Learn why interviewers love this problem, how carry propagation cascades through digits, the critical all-9s edge case that requires a new array, and why early termination makes your solution elegant — with Python and JavaScript solutions fully explained.
Most candidates try to merge nums1 and nums2 from the front and run into a subtle overwrite bug. Learn why starting from the back is the key insight, how three pointers keep the logic clean, and how this same trick powers the merge step in Merge Sort. Full Python and JavaScript solutions included.
Master the write pointer pattern — the canonical technique for in-place array modification. Full walkthrough of LeetCode 26 with visual dry run, common mistakes, and the LC 80 generalization. Python and JavaScript solutions included.
Find the one element that appears once while every other appears twice. The XOR bit trick delivers O(n) time and O(1) space — no extra memory, no sorting. Master the three XOR properties that make it work, then see how interviewers escalate to Single Number II and III.
Two problems, one pair of concepts: LC 349 asks for the unique intersection (HashSet), LC 350 asks for the frequency-aware intersection (HashMap). Master all three approaches for LC 349 — HashSet, sort+two pointers, binary search — then learn why the follow-up questions on LC 350 are what Google and Amazon actually care about: sorted input, skewed sizes, and data that does not fit in memory.
Master Pascal's Triangle (LeetCode 118 & 119) by understanding the binomial coefficient connection, the row-by-row DP pattern, space-optimized O(k) single-row generation, and five hidden mathematical properties that show up in Unique Paths, Coin Change, and beyond.
Master LeetCode 242 Valid Anagram with three approaches — sort O(n log n), 26-element frequency array O(n)/O(1), and HashMap O(n)/O(k). Includes a visual dry run, the critical Unicode follow-up, and the direct connection to Group Anagrams (LC 49).
Reverse a character array in-place using two pointers. O(n) time, O(1) space. The fundamental two-pointer swap pattern.
Find the index of the first non-repeating character in a string. Two-pass O(n) solution with a 26-array or HashMap.
Master LeetCode 125 — Valid Palindrome with the O(1)-space two-pointer technique. Learn why every FAANG loop starts here, visualize the pointer walk on a classic example, avoid the four most common pitfalls, and unlock the palindrome follow-up chain: LC 680, LC 5, and LC 647.
Find the longest common prefix string among an array of strings. Covers vertical scan O(n*m), horizontal scan, binary search, and Trie approaches with all 5 language solutions.
Count the number of prime numbers strictly less than n. Master the Sieve of Eratosthenes — one of the most elegant algorithms in CS — with full code in C, C++, Java, JavaScript and Python.
LeetCode 268 hides four distinct valid solutions behind a deceptively simple problem. Learn Sort, HashSet, Gauss Formula, and XOR — understand exactly why each exists, when interviewers ask for each one, and why XOR is the most elegant answer in the room.
The Boyer-Moore Voting Algorithm solves LeetCode 169 in O(n) time and O(1) space using a brilliantly counterintuitive cancellation trick. Learn the proof, the dry run, all four approaches, and why interviewers love this problem — plus the Majority Element II follow-up that extends the same idea to two candidates.
Find all integers in [1,n] missing from array of length n using O(n) time O(1) extra space via index negation.
Return the third distinct maximum or the max if fewer than 3 distinct values exist. Three-variable tracking O(n) O(1) solution.
Design a class to find the kth largest element in a data stream. Min-heap of size k: the top is always the answer. Full C++, Java, JavaScript and Python.
Implement Fisher-Yates shuffle for uniform random permutation. Every arrangement is equally probable. O(n) time O(1) extra space.
Compute running (prefix) sum in O(n) time O(1) extra space. The prefix sum pattern is foundational for range queries, subarray problems and 2D matrices.
Compress a sorted unique integer array into the smallest sorted list of range coverage strings.
Check if string B is a rotation of A by checking if B appears in A+A using a substring search.
Implement classic binary search to find a target in a sorted array in O(log n) time.
Find the first bad version using left-boundary binary search: shrink hi to mid when version is bad.
Find where a target would be inserted in a sorted array using left-boundary binary search returning lo.
Compute integer square root using right-boundary binary search to find the largest k where k*k <= x.
Find the picked number using binary search with the guess() API that returns -1, 0, or 1.
Count negatives in a sorted matrix in O(m+n) using the staircase approach or O(m log n) with binary search per row.
Check if a number is a perfect square in O(log n) using binary search or by exploiting odd-number sum identity.
Check if any element and its double both exist in an array using a hash set or sorting with binary search.
Every element appears twice except one. XOR all numbers: duplicates cancel (a^a=0), single number remains.
Count set bits (popcount). Brian Kernighan: n & (n-1) clears the lowest set bit; count how many operations until n=0.
Count set bits for all numbers 0..n. DP: dp[i] = dp[i >> 1] + (i & 1). Remove last bit and check if it was set.
Reverse bits of a 32-bit unsigned integer. Shift result left and input right 32 times, taking last bit each time.
Find missing number in 0..n array. XOR approach: XOR all indices with all values, duplicate indices cancel. Or math: n*(n+1)/2 - sum.
Count ways to climb n stairs taking 1 or 2 steps. Classic Fibonacci DP — dp[n] = dp[n-1] + dp[n-2] with O(1) space.
Find minimum cost to reach the top of stairs. Each stair has a cost; you can take 1 or 2 steps. DP: min cost to reach each stair.
Find the contiguous subarray with the largest sum. Kadane's algorithm: either extend previous subarray or start fresh at current element.
Maximize profit from a single buy-sell. Track running minimum price; at each day profit = price - min_so_far.
Maximize children satisfied. Sort both greed and cookie sizes; greedily assign the smallest sufficient cookie to each child.
For each element in nums1, find next greater element in nums2. Monotonic stack + hashmap: process nums2, pop when greater found, store in map.
Find two indices that add to target in O(n) by storing each number in a HashMap and looking up the complement.
Check if two strings are anagrams by comparing their character frequency counts using an array or HashMap.
Check if a ransom note can be constructed from magazine letters using a character frequency map.
Check if two strings are isomorphic by maintaining bidirectional character mappings to ensure a consistent one-to-one correspondence.
Check if a string follows a given pattern using bidirectional mapping between pattern chars and words.
Determine if a number is happy by repeatedly summing digit squares and detecting cycles using a HashSet or Floyd algorithm.
Find if any two duplicate elements are within k indices of each other using a HashMap of last-seen positions.
Find characters common to all strings in a list by intersecting their frequency arrays with element-wise minimum.
Count how many stones are jewels by storing jewel types in a HashSet and checking each stone.
Check if all value frequencies are unique using two hash sets in O(n).
Maintain a min-heap of size K to track the Kth largest element as numbers are added to a stream.
Simulate stone smashing by repeatedly extracting the two heaviest stones using a max-heap.
Assign gold/silver/bronze or rank numbers to athletes based on their scores using sorted ordering.
Sort array elements by frequency ascending, breaking ties by value descending.
Find the subsequence of length k with the largest sum by selecting top k values while preserving original order.
Reverse a singly linked list iteratively with three-pointer technique and recursively with call stack.
Find the middle node of a linked list in one pass using the slow/fast pointer technique.
Detect a cycle in a linked list in O(1) space using Floyd's two-pointer tortoise and hare algorithm.
Merge two sorted linked lists into one sorted list using a dummy head node to simplify pointer management.
Check if a linked list is a palindrome by finding the middle, reversing the second half, then comparing.
Remove duplicate nodes from a sorted linked list in O(n) with a single pointer walk.
Delete a node given only access to that node by copying the next node value and skipping the next node.
Find the intersection node of two linked lists in O(n) O(1) by switching pointers at the end of each list.
Convert a linked list representing a binary number to its integer value using left-shift accumulation.
Remove all nodes with a given value from a linked list using a dummy head to handle edge cases cleanly.
Check if a string of brackets is valid by pushing open brackets and matching close brackets against the stack.
Implement a stack using one queue by rotating all elements after each push to bring the new element to the front.
Implement a queue using two stacks with amortized O(1) operations by lazily transferring from inbox to outbox.
Design a stack with O(1) getMin by maintaining a parallel min-tracking stack alongside the main stack.
Simulate a baseball scoring game using a stack to track valid scores and handle +, D, and C operations.
Compare two strings after applying backspace characters in O(1) space by scanning from right with skip counters.
Track the minimum number of operations to return to the main folder by simulating directory navigation with a depth counter.
Count ping requests within the last 3000ms using a queue that slides expired entries off the front.
Remove adjacent pairs of same letters with different cases using a stack to build the result character by character.
Find the maximum depth of a binary tree using recursive DFS (one line) or iterative BFS level counting.
Invert a binary tree by recursively swapping left and right children at every node.
Check if a binary tree is symmetric by comparing mirror subtrees with a two-pointer recursive approach.
Determine if a root-to-leaf path exists with a given sum using DFS that subtracts each node value from the target.
Check if two binary trees are identical by recursively comparing structure and node values.
Check if a binary tree is height-balanced by computing subtree heights and returning -1 early on imbalance.
Merge two binary trees by adding overlapping node values recursively, using existing nodes where possible.
Sum all BST values in [low, high] using BST property to prune entire subtrees outside the range.
Find a node with given value in a BST by navigating left or right based on the BST property.
Find second minimum value in a special binary tree where root is min and each node equals min of its children.
Build a preorder string representation of a binary tree using parentheses to show tree structure.
Determine if two nodes are cousins (same depth, different parents) using BFS to track depth and parent.
Traverse an N-ary tree in preorder and postorder using DFS with a stack or recursion.
Rearrange a BST into a right-skewed tree with no left children using in-order traversal.
Count words with given prefix. Simple trie with count at each node; reach prefix end and return count.
Check if a string is a palindrome after removing non-alphanumeric characters using inward two pointers.
Reverse an array of characters in-place using the classic two-pointer swap technique.
Return squares of a sorted array in sorted order using two pointers that compare absolute values from both ends.
Remove all occurrences of val in-place using a write pointer pattern, returning the new length.
Remove duplicates in-place from a sorted array using a write pointer that only advances on unique elements.
Merge two sorted arrays in-place from the end to avoid overwriting elements using three pointers.
Check if string s is a subsequence of t using a greedy two-pointer scan that matches characters in order.
Count days with fixed-size window sums above upper and below lower thresholds using a sliding fixed window.
Compute the running sum of a 1D array where each element is the sum of itself and all previous elements.
Find the minimum difference between the max and min of any k scores by sorting and using a fixed window of size k.
Check if an array can be split into three consecutive parts with equal sum using a greedy counting approach.
Week 1 mock session: two carefully chosen easy/medium problems designed to build communication habits. Full problem walkthrough with example think-aloud scripts.