0254MediumLinked List

Regroup the Bucket Line

Tracked in this browser only

Trains the technique from

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.

An aerial ropeway carries buckets in single file. Every bucket is coupled to the one behind it and the trailing bucket is coupled to nothing, so the line can only be walked from the leading bucket backwards.

The harness passes plain JSON, so the line arrives as the array loads, holding the load readings from the leading bucket to the trailing one, and your answer takes the same shape: the readings in their new order, leading bucket first, or an empty array when the ropeway is running empty.

Number the buckets by their place in the line, starting at 1 for the leading bucket. Re-couple the line so that every odd-numbered bucket comes first and every even-numbered bucket follows, with the buckets inside each of those two groups keeping the order they already had. The numbering refers to a bucket's place in the line, not to its load reading.

Do this by re-coupling the buckets you were handed rather than hanging a second line of new buckets, and hold only a fixed number of bucket references beyond the line itself while you work.

Examples

Example 1

Input: loads = [45, 12, 60, 8, 33]
Output: [45, 60, 33, 12, 8]

Buckets 1, 3 and 5 carry 45, 60 and 33, and buckets 2 and 4 carry 12 and 8, so the odd-numbered group leads in that order and the even-numbered group follows in that order.

Example 2

Input: loads = [4, 7, 6, 9]
Output: [4, 6, 7, 9]

Buckets 1 and 3 carry 4 and 6 and buckets 2 and 4 carry 7 and 9, which is the order they appear in the answer.

Example 3

Input: loads = []
Output: []

An empty ropeway has nothing to re-couple.

Constraints

0 <= loads.length <= 10^4
-10^6 <= loads[i] <= 10^6
Only a fixed number of bucket references may be held beyond the line itself

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 regroup_bucket_line(loads: list[int]) -> list[int]:

Java

public int[] regroupBucketLine(int[] loads)

The intended approach

Time O(n)Space O(n) for the coupling chain rebuilt from the input and the returned readings, plus O(1) bucket references beyond them

Rebuild the coupling chain from the readings, then keep two working references, one on the last odd-numbered bucket found so far and one on the last even-numbered bucket. Each turn of the loop couples the odd reference to the bucket two places along, then the even reference to the bucket two places along from it, advancing both; when the even side runs out, couple the tail of the odd group to the first even-numbered bucket. Finally read the readings back off the chain in their new coupling order.

Pythonentry point: regroup_bucket_line

def regroup_bucket_line(loads):
    class Bucket:
        __slots__ = ("load", "behind")

        def __init__(self, load):
            self.load = load
            self.behind = None

    lead = None
    last = None
    for load in loads:
        bucket = Bucket(load)
        if lead is None:
            lead = bucket
        else:
            last.behind = bucket
        last = bucket

    if lead is not None and lead.behind is not None:
        odd = lead
        even = lead.behind
        even_lead = even
        while even is not None and even.behind is not None:
            odd.behind = even.behind
            odd = odd.behind
            even.behind = odd.behind
            even = even.behind
        odd.behind = even_lead

    out = []
    walker = lead
    while walker is not None:
        out.append(walker.load)
        walker = walker.behind
    return out

The obvious version

Walk the readings by place number and drop each into one of two fresh lists, then join the two lists. Plain index arithmetic instead of any coupling work.

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_regroup_bucket_line(loads):
    front = []
    back = []
    for place in range(1, len(loads) + 1):
        if place % 2 == 1:
            front.append(loads[place - 1])
        else:
            back.append(loads[place - 1])
    return front + back

How this problem was checked

Reference solution executed against 11 test cases — 11 passed
3 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