28 articles
Next Permutation is not just an array problem — it is a test of systematic algorithmic thinking under pressure. Learn why you scan from the right, why you swap with the smallest larger element, and why the suffix is reversed rather than sorted. Includes full visual dry runs, the 4 most common bugs, and Python + JavaScript solutions.
Master Dijkstra's Dutch National Flag algorithm to sort 0s, 1s, and 2s in a single pass with O(1) space. Understand the three-pointer invariants, the critical bug most candidates make, and how this pattern unlocks a family of partition problems.
Generate the power set of distinct integers using backtracking or bitmask enumeration.
Determine if there exists an increasing subsequence of length 3 using two greedy variables in O(n) time O(1) space.
LeetCode 128 — Find the longest consecutive integer sequence in O(n) using a HashSet. The trick: only start counting from numbers where num-1 is NOT in the set, so each element is visited at most twice total across the entire algorithm.
Calculate minimum CPU intervals for tasks with cooldown using a greedy formula based on the most frequent task count.
Maximize a number by making at most one swap, using a last-occurrence map to find the optimal swap greedily.
Find a peak element in O(log n) by binary searching on the slope direction — always move toward the higher neighbor.
LeetCode 42 is a benchmark Hard problem used by Amazon, Google, and Meta to test whether you can derive an insight — not just memorize code. Learn all three approaches (brute force, prefix arrays, two pointers) and — crucially — understand WHY the two-pointer invariant works.
Master LeetCode 76 — the gold-standard Hard sliding window problem asked at Google, Meta, and Amazon. Learn the "formed" counter trick that reduces window validity checks from O(|t|) to O(1), trace through a full dry run, and avoid the five bugs that trip up 90% of candidates.
LeetCode 4 is one of the most feared Hard problems in FAANG interviews. Learn exactly why the partition insight works, trace through a full binary search dry run, understand the five common bugs that cause silent wrong answers, and walk away with production-quality Python and JavaScript solutions.
Find two indices that add to target in O(n) by storing each number in a HashMap and looking up the complement.
Group strings that are anagrams together by using their sorted form as a HashMap key.
Find the k most frequent elements in O(n) using bucket sort by frequency instead of a heap.
Design a Least Recently Used cache with O(1) get and put operations using a HashMap combined with a doubly linked list.
Count subarrays with sum exactly k using prefix sums stored in a HashMap to find valid starting positions in O(n).
Find the longest consecutive integer sequence in O(n) by using a HashSet and only starting sequences from their minimum element.
Design a set with O(1) insert, delete, and getRandom using a dynamic array combined with a HashMap for index tracking.
Remove duplicates in-place from a sorted array using a write pointer that only advances on unique elements.
Find the longest substring without duplicate characters using a HashSet-backed shrinkable sliding window.
Maximize water trapped between two vertical lines using inward two pointers that always move the shorter line inward.
Find all unique triplets summing to zero by sorting and using two pointers for each fixed element with careful duplicate skipping.
Find the maximum consecutive ones in a binary array when you can flip at most k zeros, identical to the Max Consecutive Ones III pattern.
Find the smallest window in s containing all characters of t using a have/need counter to track when the window is valid.
Find the longest substring containing at most 2 distinct characters using a variable sliding window with a character count map.
Sort an array of 0s, 1s, and 2s in one pass using the Dutch National Flag 3-pointer algorithm.
Check if a string can become a palindrome by deleting at most one character using recursive two-pointer palindrome checking.
Calculate trapped rainwater using optimal two-pointer approach that tracks left and right maximums without extra space.