Arrays

Build a new string with the characters flipped: swap from both ends of a char array, or use StringBuilder.reverse().

Repeatedly emit zero-in-degree nodes and decrement their successors; the emission order is a topological sort, and a short count means a cycle.

DFS each node, push it after its descendants finish (post-order), then reverse the post-order to get the topological sort; use three colors to catch cycles.

Start by assuming the first element is the biggest, then walk the array once and upgrade max whenever something larger appears.

Assume the first element is the smallest, then walk the array once and downgrade min whenever something smaller appears.

Walk the array once with a counter, and add one to the counter every time an element matches the target.

Scan the array and return true at the first match; return false only after checking every element.

Swap the two ends and move inward with two pointers until they meet, reversing the array in place.

Make a fresh array of the same size and place each element into it; for objects this copies references, not the objects themselves.

Put one pointer at each end, swap, step both inward, and stop when they meet.

Walk adjacent pairs; if any earlier element is greater than the next, it is not sorted; otherwise it is.

Slow pointer holds the last unique value; when fast finds a new value, bump slow and copy it there.

Keep the k largest in a size-k min-heap, and its root is the kth largest, in O(n log k) time.

Seed max and min with the first element, then scan once, updating each when you see something bigger or smaller.

Keep a gold and a silver tracker; a new champion pushes gold down to silver, otherwise it may just claim silver.

Check that k nodes remain, reverse that block in place, reconnect it, then repeat; leave a short final block alone.

For each element choose include or exclude; record the path at every step to get all 2^n subsets.

Fill positions one by one with unused elements; when full, record the ordering and backtrack: n! results.

Push operands, and on each operator pop two, compute, and push the result: the last value on the stack is the answer.

Find where order first and last breaks, then stretch the window until the outside fully brackets the inside's min and max.

Treat each value as a next-index pointer; the duplicate is the entry of the cycle those pointers form.

Array gives fast index access but slow middle insert; linked list gives slow access but fast head insert.

At each element take the larger of extending the run or starting new, and track the best run seen.

Keep running max and min products, swap them on a negative element, and track the global best.

Compare middle to the right boundary and keep the half that still contains the drop point.

One half around the middle is always sorted, so check if the target fits in it and keep that half.

Merge from the back, placing the larger of the two tails into the last empty slot, moving backward.

Count with a frequency map, or when values are one to n, flip the sign at the indexed slot and a pre-flipped slot means a duplicate.

Binary-search a partition in the smaller array so left holds half the total and the boundary values cross correctly.

On sorted data, two opposite-end pointers find a target pair in one linear pass with zero extra memory.

A slow write pointer plus a fast scan pointer compacts a sorted array to its unique values in one pass with no extra memory.

For each index, multiply the product of everything to the left by the product of everything to the right, using two sweeps and no division.

An array queue is a ring of slots where a front pointer and a rear pointer chase each other around using modulo.

Store elements in an array for fair random indexing and keep a map from element to index, deleting by swapping with the last element so every operation stays constant time.

Reduce K by the length, then reverse the whole array, reverse the first K, and reverse the rest.

Keep a running window sum by adding the entering element and subtracting the leaving one, and track the maximum.

Grow the window on the right until the sum reaches the target, then shrink from the left while it still qualifies, tracking the minimum length.

Use an array plus a top index starting at minus one; push writes and moves top up, pop reads and moves top down, peek reads without moving.

Put left and right pointers at the ends of a char array and swap inward until they cross.

Preprocess running totals in the constructor, answer each sumRange with one subtraction.

Keep a running sum and a count of seen sums; at each step add how many times currentSum minus K was seen.

Turn zeros into minus ones; equal counts mean the running sum repeats, so the gap between equal sums is a balanced subarray.

Fill each slot with the product of everything on its left, then multiply in the product of everything on its right.

Count frequencies in a map, then pick the top K with a size-K min-heap or with frequency buckets.

If the total sum is even, ask whether any subset sums to exactly half using a boolean reachability DP array.

Replace boolean OR with integer addition in the subset-sum DP to count how many subsets reach the target.

The fewest jumps to reach a position is one plus the fewest jumps to the best reachable predecessor.

Binary-search to the target, then expand two pointers outward taking the closer side each time until K numbers are chosen.

Count frequencies, keep singles for free, then spend K removals clearing the smallest surplus counts first via a min-heap.

The window from heap-min to running-max always covers all lists; shrink it by advancing the minimum.

Seed a min-heap with one element per array, pop the global minimum into the output, and push the successor from the same array.

Treat each row as a sorted list, run K-way Merge across rows, and stop at the Kth pop.

Two-way merge the sorted arrays but stop at the middle position to read off the median.

Grow the window while the zero count stays at most k; when it exceeds k, shrink from the left until the budget is restored.

Grow right until the sum reaches the target, then shrink left while it still qualifies, tracking the shortest window.

At each element, either extend the running sum or restart from this element, and keep the best running sum ever seen.

At each element, either extend the running minimum or restart from this element, and keep the smallest running sum ever seen.

Track both the running maximum and running minimum product, because a negative flips them, and a zero resets both.

Carry two running sums: one with no deletion used, one with a deletion already spent, and update each from the other.

The best circular sum is the larger of the normal Kadane maximum and the total minus the minimum subarray, with an all-negative guard.

Count earlier prefix sums equal to the current prefix sum minus k, using a hash map of prefix-sum frequencies.

At each index, check whether leftSum equals total minus leftSum minus the current element; the first match is the pivot.

Two prefix sums sharing the same remainder mod k bound a subarray divisible by k, so count equal-remainder pairs.

Map zero to -1, track the prefix sum, and the longest span between equal prefix values is the longest balanced subarray.

Use prefix sums with a deque that stays increasing; pop the front when the window qualifies, pop the back when a newer prefix is not larger.

Keep previous, current, and a saved next; point current back to previous each step, and previous ends as the new head.

Reach the node before `p`, reverse the middle run, then reconnect both boundaries.

Reverse each full k-node group and re-link group boundaries; leave a trailing partial group alone.

Reverse k, then skip k, repeating; it is reverse-in-groups with an added skip step each cycle.

In a sorted array, start with pointers at both ends, then squeeze inward: too big means shrink the right, too small means grow the left.

The largest squares hide at the ends, so compare the two ends by magnitude, square the bigger, and fill the result from the back.

Grow the window on the right, shrink on the left when the product reaches the target, and add the window length at each step to count valid subarrays.

Detect ascending or descending once by comparing the endpoints, then binary-search with the comparison flipped to match the direction.

Binary-search; when the key is not found, the start pointer lands on the smallest value greater than or equal to the key.

Run binary search twice, once biased left for the first index and once biased right for the last index of the key.

Exponentially double a window until it brackets the key, then binary-search within that bracket.

Binary-search; if the key is absent the start and end pointers straddle it, so return whichever neighbour is closer, preferring the smaller on a tie.

Compare mid with its right neighbour; climbing means go right, falling means go left, and the pointers meet at the peak.

Find the peak, binary-search the ascending left half, then if needed binary-search the descending right half, returning the earlier match.

One half is always sorted; check if the key lies in that sorted half's range, and keep that half or discard it.

The rotation count equals the index of the minimum, so binary-search for the smallest element and return its index.

XOR all numbers together; pairs cancel to zero and the single unpaired number survives.

XOR everything to combine the two singles, isolate a differing bit, split into two groups by that bit, and XOR each group to recover each single.

Compare the middle element to the target, then discard the half that cannot contain it, repeating until found or the window closes.

Compare the middle element to the rightmost element to determine which half contains the inflection point where the minimum lives.

At each step one half is sorted, so check if the target fits that half and go there, else go the other way.

Compare the middle element to its right neighbor and always walk uphill; a peak is guaranteed in that direction because boundaries are negative infinity.

Walk the array once and bump each element's count in a HashMap using `merge` or `getOrDefault`, giving O(n) time and O(k) space.

Add each element to a HashSet; if add returns false, you have found a duplicate.

Sort first, and for a repeated element extend only the subsets added in the previous round to avoid duplicate subsets.

current = max(num, current + num); answer = max(answer, current) : extend or restart each step.

Fast-slow on modular jumps, but a valid loop must keep one direction and be longer than a single self-pointing slot.

Sum the first window once, then slide by adding the new element and subtracting the old one, tracking the max.

Grow right until you hit the target, then shrink left as far as you can, tracking the smallest length.

Keep a decreasing stack of pending values, and each new value resolves every smaller value on top of the stack as its next greater element.

Keep running max AND min; a negative swaps them; answer is the global max.

Count with a hash map, then keep the k highest counts in a size-k min-heap keyed by frequency.

Find the middle, reverse the second half, compare the two halves, then optionally reverse back.

Move one pointer by one and another by two; when the fast one finishes, the slow one is at the middle.

Flip each next pointer to the previous node, tracking previous, current, and next so the remaining list is never lost.

Find the middle, reverse the back half, compare both halves, then reverse back to restore.

Split at the middle, reverse the back half, then interleave front and back node by node.

Clone each node, then fix the random pointers using either a map from original to clone or by interleaving clones behind originals.

Do normal level-order BFS, but add each level to the front of the result so the bottom level comes out first.

Binary-search a partition of the smaller array so the two combined halves are balanced; read the median at the boundary.

Inorder traversal yields sorted order, so the kth node you visit is the kth smallest, and you can stop early.

Keep a size-K min-heap whose root is the Kth largest, or use QuickSelect to partition toward the target rank in average O(n).

Tally frequencies in a HashMap, then take the top K with a size-K min-heap or with frequency-indexed bucket sort.

Two baskets means at most two distinct types, so it is the longest window with two distinct values.