Practice how to think, not just how to code.

Find the two indices whose values add to a target.

Determine if one string is a permutation of another.

Design a cache with O(1) get and put using LRU eviction.

Detect a cycle in a directed dependency graph.

Can a string be segmented into dictionary words?

Count connected components of land in a grid.

How much water can be trapped between elevation bars?

Find the median of two sorted arrays in O(log(min(n, m))).

Find the maximum profit from a single buy-sell pair in a price series.

Find the contiguous subarray with the largest sum (Kadane's algorithm).

Count the distinct ways to reach the top of an n-step staircase.

Decide whether a string of brackets is balanced.

Detect whether any value appears more than once in an array.

Pick two vertical lines that, with the x-axis, hold the most water.

Find all unique triplets in the array that sum to zero.

Find the length of the longest substring containing all unique characters.

Return the k most frequent elements from an integer array.

Return an array where output[i] is the product of every other element.

Merge all overlapping intervals and return the sorted, merged result.

Find a target in a sorted array that has been rotated at an unknown pivot.

Find the fewest coins needed to make a target amount.

Maximize loot from a row of houses where adjacent houses can't both be robbed.

Return the longest palindromic substring of s (expand-around-center).

Generate all subsets (the power set) of a unique-integer array.

Count how many ways a digit string can be decoded into letters A–Z.

Find the length of the longest strictly increasing subsequence of nums.

Compute the minimum insert/delete/replace ops to convert word1 into word2.

Return the maximum of every window of size k as it slides over nums.

Reverse a singly linked list in place and return the new head.

Mirror every node's left/right children and return the new root.

Find the length of the longest run of consecutive integers in O(n).

Given nums in [0, n] with one missing, return the missing number.

Find the one element that appears once in an array where every other appears twice.

Find the element that appears more than ⌊n/2⌋ times (Boyer-Moore vote).

Return unique values that appear in both arrays.

Move all 0s to the end while preserving the relative order of non-zero elements.

Determine if a partially filled 9×9 Sudoku board is valid.

Decide whether the squares-of-digits process eventually reaches 1.

Decide whether s and t are isomorphic via a consistent character mapping.

Increment a big integer represented as an array of digits.

Decide if a string reads the same forwards and backwards (alphanumeric, case-insensitive).

Find two 1-indexed numbers in a sorted array that sum to target.

Sort an array of 0/1/2 values in a single pass (Dutch national flag).

Return the sum of three integers closest to the target.

Square each element of a sorted array; return the result in non-decreasing order.

Decide whether s appears as a subsequence of t.

Decide if two strings are equal after applying '#' as backspace.

Split a string into the largest possible parts where every letter appears in only one part.

Pair the heaviest with the lightest; minimize boats given a weight limit.

Reverse a string.

Find the longest substring you can make uniform by changing at most k characters.

Decide whether s2 contains any permutation of s1 as a substring.

Return all start indices of anagrams of p inside s.

Longest contiguous subarray containing at most 2 distinct values.

Count contiguous subarrays whose sum equals k.

Smallest contiguous subarray with sum ≥ target (positives only).

Maximum vowels within any window of length k.

Longest substring containing no more than k distinct characters.

Smallest window in s containing every character of t (with multiplicity).

Length of the longest run of 1s in a binary array.

Evaluate an arithmetic expression in postfix (RPN) notation.

For each day, find how many days until a warmer temperature.

For each value in nums1, find its next greater value in nums2.

Next greater element in a circular array.

Simulate asteroid collisions; positives move right, negatives move left.

Convert a Unix-style absolute path to its canonical form.

Expand encoded strings of the form `k[encoded_string]`.

Remove k digits from a number string to make the smallest number.

Find the largest rectangle that fits within a histogram of bar heights.

Check if a pop sequence is achievable from a push sequence using a stack.

Classic binary search on a sorted array.

Search a row- and column-sorted matrix where row[i+1][0] > row[i][last].

Find the minimum in a rotated, otherwise-sorted array of unique values.

Return the index where target would be inserted in sorted nums.

Find the minimum eating speed k that finishes all piles within h hours.

Minimum ship capacity to deliver weights[] in order within `days` days.

Return [first, last] indices of target in a sorted array, or [-1, -1].

Search in a matrix sorted by rows and columns (weaker invariant).

Compute integer square root truncated toward zero.

Find the unique element in a sorted array where every other appears twice.

Merge two sorted linked lists into one sorted list.

Merge k sorted linked lists into one sorted list.

Remove the nth node counting from the end of a linked list.

Add two numbers represented as reverse-order linked lists.

Swap every two adjacent nodes in a linked list.

Reorder L0→L1→…→Ln−1→Ln into L0→Ln→L1→Ln−1→L2→Ln−2→… in place.

Decide whether a linked list is a palindrome.

Return the second middle node (or the only middle for odd lengths).

Group nodes at odd positions before nodes at even positions (1-indexed).

Delete all duplicates so each value appears at most once.

Reorder so all nodes < x come before all nodes ≥ x, preserving relative order.

Rotate the list to the right by k places.

Reverse the nodes between positions left and right (1-indexed).

Reverse the nodes of the list k at a time; leave any remaining tail as-is.

Return the depth of the deepest leaf in a binary tree.

Decide whether two binary trees are structurally and value-wise identical.

Decide whether a binary tree is mirror-symmetric around its center.

Decide whether a binary tree is height-balanced.

Length of the longest path between any two nodes in a tree.

Return the values at each level (top to bottom).

Level order traversal where direction alternates per level.

Return the values of the rightmost node at each level.

Decide whether a binary tree is a strict BST.

Find the lowest common ancestor of two values in a BST (return the LCA node's value).

LCA in a generic binary tree (no BST property). Returns LCA node's value.

Return the k-th smallest element in a BST.

Decide whether some root-to-leaf path sums to target.

Maximum sum of any path between any two nodes (path may not pass through root).

Count nodes whose value is ≥ every value on the root-to-node path.

Return the preorder traversal of a tree (root, left, right).

Return the inorder traversal of a tree (left, root, right).

Return the postorder traversal of a tree (left, right, root).

Replace each word in a sentence with its shortest dictionary root.

Find the longest word in dictionary that can be formed by deleting characters of s.

Decide whether a string follows a given pattern via bijective mapping.

Find the longest common prefix of an array of strings.

Longest word that can be built one char at a time from other words in the dictionary.

Find the k-th largest value in an array.

Simulate stone smashing using a max-heap; return the final stone's weight.

Return the k points closest to (0,0) under Euclidean distance.

Pick at most k profitable projects under capital constraints.

Rearrange characters so that no two adjacent characters are equal.

Repeatedly combine the two cheapest sticks; return total cost.

Greedy: spend ladders on the largest jumps, bricks on smaller ones.

Return the k pairs with the smallest sums from two sorted arrays.

Decide whether car capacity is enough across all trips.

Greedy: always refuel at the largest unused station that is still reachable.

Minimum number of conference rooms to host all meetings.

Maximize sum(speed) × min(efficiency) for a team of at most k engineers.

Return all unique subsets of an array that may contain duplicates.

Return all permutations of a unique-integer array.

Return all unique permutations when the input contains duplicates.

Return all combinations of k numbers chosen from 1..n.

All combinations from candidates that sum to target. Each candidate may be reused.

Each candidate may be used at most once; result must contain unique combinations.

Find k-element combinations from 1..9 summing to n.

Return all letter combinations the digit string could represent (T9 keypad).

Generate all combinations of n well-formed parentheses.

Decide whether a word can be traced through adjacent cells in a board.

Return all valid IPv4 addresses formed by inserting dots into a digit string.

Largest 4-connected '1' region in a binary grid.

Replace all 4-connected pixels of a region with a target color.

Multi-source BFS for the time until all fresh oranges rot.

Cells from which water can flow to both oceans.

Shortest 8-connected path of zeros from top-left to bottom-right.

Return a valid order to take all courses or [] if impossible.

Count the number of connected components.

Decide whether an undirected graph is a tree (connected and acyclic).

Find the edge that, if removed, makes the graph a tree.

Length of the shortest transformation sequence between two words.

Time for a signal sent from k to reach all nodes (Dijkstra).

Cheapest path from src to dst using at most k stops (Bellman-Ford).

Minimum spanning tree of points under Manhattan distance.

Minimum time to swim from top-left to bottom-right (Dijkstra on max edge).

Infer the alphabet order from a list of words sorted in alien-language order.

Path from top-left to bottom-right minimizing maximum height delta.

Count connected components from a friendship adjacency matrix.

Decide whether the given undirected graph is bipartite via 2-coloring.

Roots that minimize tree height — at most 2 valid centroids.

Find the unique node trusted by everyone but trusts no one.

Decide whether all rooms can be visited starting from room 0.

Houses arranged in a circle — adjacent houses cannot both be robbed.

Number of distinct combinations of coins that sum to amount.

Decide whether the array can be split into two equal-sum subsets.

Largest contiguous-subarray product, accounting for negatives.

Minimum cost to reach the top, taking 1 or 2 steps at a time.

Number of ways to assign +/- signs to make the sum equal target.

Least number of perfect squares that sum to n.

Maximum product when breaking n into ≥ 2 positive integers.

Number of paths from top-left to bottom-right moving only right or down.

Same as Unique Paths, but with obstacles blocking some cells.

Cheapest path from top-left to bottom-right (right/down only).

Length of the longest subsequence common to two strings.

Number of distinct subsequences of s that equal t.

Decide whether s3 is an interleaving of s1 and s2.

Length of the longest subsequence of s that is a palindrome.

Implement '.' and '*' regex matching against an input string.

Decide whether you can reach the last index from the first.

Minimum number of jumps to reach the last index.

Find a starting station to complete the circuit, or -1 if impossible.

Decide whether the hand can be split into groups of consecutive cards.

Decide whether the string with '(', ')', '*' wildcards is a valid balanced expression.

Distribute minimum candy so children with higher ratings get more than neighbors.

Minimum time to complete all tasks with cooldown constraint.

Reconstruct queue from (height, k) pairs.

Insert a new interval into a sorted, non-overlapping list and merge as needed.

Min number of intervals to remove so the rest are non-overlapping.

Min number of arrows to pop all balloons (intervals on a number line).

Decide whether one person can attend every meeting (no overlaps).

Intersection of two sorted, non-overlapping interval lists.

Min number of clips needed to cover [0, time].

Longest chain of pairs (a, b) where each next pair starts after previous ends.

Compress a sorted unique int list into ranges like '0->2'.

Count intervals after removing those fully covered by another interval.

Length of the longest alternating-difference subsequence.

Compute x raised to the integer power n in O(log |n|).

Count primes strictly less than n using the Sieve of Eratosthenes.

Multiply two non-negative integers represented as strings.

Add two binary strings and return the binary sum as a string.

Convert an Excel column title (A, B, ..., Z, AA, AB, ...) to its column number.

Convert an integer column number to its Excel-style title.

Convert a Roman numeral string to an integer.

Convert an integer in [1, 3999] to its Roman-numeral representation.

Count the number of '1' bits in a non-negative integer.

Return an array where ans[i] = number of 1's in binary representation of i.

Number of bit positions where two integers differ.

Decide whether a positive integer is a power of two.

Decide whether n is a power of three.

Decide whether n is a power of four.

Find the extra letter that appears in t but not in s.

Find the element that appears once when every other element appears thrice.

Return the n-th Fibonacci number.

Return the n-th Tribonacci number (sum of previous three).

Decide whether the magazine letters can construct the ransom note.

Decide whether n's only prime factors are 2, 3, 5.

Find the n-th ugly number (only prime factors 2, 3, 5).

Largest k such that k(k+1)/2 ≤ n.

Decide whether n is a perfect square (without sqrt).

Repeatedly sum a number's digits until a single-digit number remains.

Decide whether the array is entirely non-decreasing or entirely non-increasing.

Smallest index where left-sum equals right-sum.

Decide whether goal is a rotation of s.

Reverse digits of a 32-bit signed integer; return 0 on overflow.

Find the two numbers that appear once when every other number appears twice.

Flip every bit in the binary representation of n.

Convert an integer to its base-7 string representation.

Count triplets that can form the sides of a triangle.

Largest sum among all contiguous subarrays of length k.

Pick exactly k cards from either end to maximize total points.

Largest k-window sum where every element is distinct.

Length of the longest substring of well-formed parentheses.

Return the k closest values to x, in ascending order.

Sum of |left subtree sum − right subtree sum| over every node.

Return all root-to-leaf paths whose values sum to the target.

Longest path (in edges) between any two nodes with equal values.

Return the sum of node values at each level (top-down).

Width of the widest level (counting null gaps between extremes).

Capture every 'O' region not connected to the border by flipping to 'X'.

Fewest knight moves from (0,0) to (x,y) on an infinite board.

Distance from each cell to the nearest 0 in a binary matrix.

Fewest buses to take to get from source to target.

City with fewest reachable cities within `distanceThreshold` (ties → largest id).

Largest square sub-matrix containing only 1s; return its area.

Pick non-overlapping jobs to maximize total profit.

Cheapest way to paint n houses with no two adjacent same color (3 colors).

Same as Paint House but with k colors — solve in O(n·k).

Smallest window in s of which t is a subsequence (preserving order).

Return all elements of a matrix in spiral order.

Rotate an n×n matrix 90° clockwise in place.

If an element is 0, set its entire row and column to 0 in place.

Count substrings consisting of only vowels and containing all five.

Design a trie supporting `insert`, `search`, and `startsWith` in O(L).

Maintain the running median of a stream with O(log n) inserts and O(1) reads.