0206EasyLinked List

Trim Repeat Holds

Tracked in this browser only

Trains the technique from

LeetCode 83Remove Duplicates from Sorted List

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A freeze-dryer runs a recipe built from holds wired one behind another. A hold knows only its target temperature in Celsius and which hold comes after it, and nothing in the machine records how many holds a recipe has. Targets never fall as the run proceeds, and neighbouring holds may carry the same target.

The recipe reaches you as holds, a flat list of the target temperatures in run order. That flat list is the JSON stand-in for the wired chain, so [] stands for a recipe with no holds in it at all, and the answer is a flat list of the same kind.

A hold that repeats the target of the hold in front of it changes nothing about the run, so unhook every such hold and hand back the chain that remains, in run order. Each target that appears in the recipe has to appear exactly once in the answer. Unhook the repeats from the chain you were handed instead of assembling a fresh chain alongside it.

Examples

Example 1

Input: holds = [-40, -40, -12, 5, 5, 5]
Output: [-40, -12, 5]

The second -40 repeats the hold in front of it, and two of the three 5 holds do the same, so those three unhook and the chain keeps -40, -12 and 5 in run order.

Example 2

Input: holds = [8, 8]
Output: [8]

The second hold repeats the first, so it unhooks and one hold at 8 is left.

Example 3

Input: holds = [-100, -7, 0, 63]
Output: [-100, -7, 0, 63]

No hold repeats the target in front of it, so the chain comes back untouched.

Example 4

Input: holds = []
Output: []

A recipe with no holds has nothing to unhook, so the answer is an empty chain.

Constraints

0 <= holds.length <= 300
-100 <= holds[i] <= 100
holds is given in non-decreasing order

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def trim_repeat_holds(holds: list[int]) -> list[int]:

Java

public int[] trimRepeatHolds(int[] holds)

The intended approach

Time O(n)Space O(1) beyond the chain handed in, which is reworked in place

Because targets never fall, every repeat of a target sits immediately behind the hold it repeats, so a single walk is enough. Keep a cursor on the last hold that survived and move a second cursor down the chain: when the hold under the second cursor carries a new target, it becomes the next survivor and is wired in behind the first cursor, and when it repeats, it is passed over and drops out. Cutting the chain after the final survivor finishes the job.

Pythonentry point: trim_repeat_holds

def trim_repeat_holds(holds):
    # Time O(n): one walk down the chain. Space O(1) beyond the chain handed in,
    # which is reworked in place; nothing is copied into a second structure.
    if not holds:
        return holds
    keep = 0
    probe = 1
    while probe < len(holds):
        if holds[probe] != holds[keep]:
            keep += 1
            holds[keep] = holds[probe]
        probe += 1
    del holds[keep + 1:]
    return holds

The obvious version

Ignore the chain order: collect the distinct targets in a set and sort them. The non-decreasing guarantee makes the sorted distinct targets the same chain the walk produces.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_trim_repeat_holds(holds):
    distinct = set()
    for target in holds:
        distinct.add(target)
    return sorted(distinct)

How this problem was checked

Reference solution executed against 16 test cases — 16 passed
4 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in