Miscellaneous Coding

Match: use + skip (diagonal + above); mismatch: skip only (above). dp[i][0] = 1.

Track the lowest price so far and the best sell-today-minus-lowest profit in one pass.

Validate on read against the expiry, and stamp every expiry record with a version so a late cleanup never deletes a newer rewrite.

Keep a max-heap for the lower half and a min-heap for the upper half, balanced in size; the median is the larger heap's top or the average of both tops.

A HashMap for O(1) lookup plus a doubly linked list for recency order gives constant-time get and put with least-recently-used eviction.

A payment gateway moves money through validated, idempotent, Saga-coordinated steps, publishes events via an outbox to Kafka, and stays resilient with circuit breakers and observable with metrics, logs, and traces.

OAuth2 issues a signed, short-lived JWT the client carries on every request; services verify its signature with a public key; and each OWASP risk has a specific defense applied by default.

The heap stores objects and the garbage collector cleans it, each thread gets its own stack, metaspace holds class metadata, and the JIT compiler turns hot bytecode into fast native machine code.

Precompute running totals once, then any range sum is just one subtraction of two prefix values.

Print the number, but say Fizz for multiples of three, Buzz for multiples of five, and FizzBuzz for multiples of both.

The answer is the maximum of total tasks and the skeleton length driven by the most frequent task, which is (maxCount − 1) × (N + 1) + (number of tasks tied at maxCount).

Split at every operator, recurse on both sides, and combine all left results with all right results.

Union emails that appear together, then group by root: each root is one merged person with sorted emails.

P = (total + target) / 2; count subsets summing to P; dp[s] += dp[s - num].

Use a size-K max-heap keyed on squared distance; offer each point and evict the farthest when size exceeds K, leaving the K closest in O(n log K).

Start at n, union every connected pair in the matrix, and the leftover count is the number of provinces.

Sort by comparing the string a+b against b+a and put the bigger concatenation first.

A write pointer collects non-zeros in order at the front; then fill the rest with zeros at the end.

Write every non-zero to the front with a slow pointer, then pad the rest with zeros: order preserved, no extra array.

Combine and reverse with add-subtract or XOR three times, and the two values trade places with no temporary.

Reduce signed sums to counting subsets that total (sum + target) / 2.

Each cell is 1 + the best smaller-earlier cell, and predecessor links rebuild the actual run.

One trade tracks the min and best sell; many trades sum every positive daily gain.

Signs turn into a subset: count subsets summing to (total + target) / 2.

Cut a rod of length N into pieces to maximize revenue using a 1D unbounded knapsack DP that sweeps upward to allow reusing the same cut length.

Maximize the number of pieces from a ribbon of length N using allowed cut lengths, with a sentinel-based DP that guards against building on unreachable remainders.

Find the maximum sum of non-adjacent elements using two rolling variables where each state depends on the two preceding states.

Find the longest palindromic subsequence by comparing the two ends of each range: if they match add 2 to the inner answer, otherwise take the better of dropping either end.

Find the maximum sum of a strictly increasing subsequence by seeding each index with its own value and extending from the best earlier smaller-value sum.

All tasks can be finished if and only if Kahn's algorithm places every task, meaning the prerequisite graph has no cycle.

Record the removal sequence from Kahn's algorithm as a valid task completion order, returning empty if a cycle prevents completion.

Enumerate every valid topological order by branching on each zero-in-degree task at every step, recursing, and backtracking to explore all choices.

Walk each sentence word through a trie of root words and cut it at the first node marked as a root, giving the shortest matching prefix.

Walk to the prefix node in the trie, then collect every complete word in the subtree below it using depth-first search.

Treat each word as a node in an implicit graph where one-letter changes are edges, then BFS from the begin word gives the shortest valid chain to the end word.

Keep a min-heap of size K where a new number replaces the root only if it is larger, so the heap always holds the K largest numbers seen so far.

Keep a max-heap of size K ordered by squared distance from the origin, where a closer point evicts the farthest kept point.

Always join the two shortest ropes using a min-heap, accumulate each join's cost, and push the combined rope back until one rope remains.

Count frequencies in a hash map, then keep a size-K min-heap keyed on frequency, evicting the least frequent when the heap overflows.

Split the stream into a smaller half in a max-heap and a larger half in a min-heap, keep them balanced, and the median lives at the boundary between the two tops.

Count contiguous subarrays whose sum lies within a given range by reframing the problem as counting prefix-sum pairs and using a merge-sort-based counting technique for O(n log n) time.

Place each in-range positive value at its home index using cyclic sort, then the first empty home gives the smallest missing positive.

Run cyclic placement, emit empty homes as missing, then extend past n skipping observed strays until you have k missing positives.

4Sum finds all unique quadruplets in an array that add up to a target by sorting, fixing two elements with nested loops, and scanning the remaining two with a two-pointer technique.

Binary-search for the smallest letter strictly greater than the key, and take the start pointer modulo the length to wrap around.

At each character choose to keep it or to count it, flushing the running count whenever you keep a character or reach the end.

Track the lowest price so far and the best sell-today profit; the maximum of those profits is the answer.

Fast moves two, slow moves one; when fast hits the end, slow is the middle.

Split at the middle, reverse the back half, then zip the two halves together alternately.

Keep a running prefix sum and a count map, and at each node add the number of earlier prefixes equal to current prefix minus the target.

Insert roots into a Trie, then for each sentence word walk the Trie and replace it with the first (shortest) root hit, else leave it unchanged.

Find the maximum of N values in one pass by seeding with the first value and replacing the running maximum whenever a larger value arrives.