0526EasyArraySimulation

Splitting Parcels Onto Two Intake Trays

Tracked in this browser only

Trains the technique from

LeetCode 3069Distribute Elements Into Two Arrays I

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.

Parcels come off a chute one after another, their weights listed in weights. No two parcels weigh the same. A sorter stacks them on two trays, each new parcel going on top of the tray it is sent to.

The first parcel goes on the near tray and the second on the far tray. Every parcel after that is placed by looking at the parcel currently on top of each tray: if the near tray's top parcel is heavier than the far tray's top parcel, the new parcel goes on the near tray, and otherwise it goes on the far tray.

Return one list holding the near tray read from the bottom up, followed by the far tray read from the bottom up.

Examples

Example 1

Input: weights = [7, 4, 9, 2, 6]
Output: [7, 9, 2, 4, 6]

Parcel 7 goes near and parcel 4 goes far. Parcel 9 arrives with tops 7 and 4, so it goes near; parcel 2 arrives with tops 9 and 4, so it goes near; parcel 6 arrives with tops 2 and 4, so it goes far. The near tray reads 7, 9, 2 and the far tray reads 4, 6.

Example 2

Input: weights = [9, 8, 7, 6]
Output: [9, 7, 8, 6]

Parcel 7 arrives with tops 9 and 8 and goes near. Parcel 6 then arrives with tops 7 and 8 and goes far, leaving the near tray as 9, 7 and the far tray as 8, 6.

Example 3

Input: weights = [4, 100, 3, 99, 2]
Output: [4, 99, 2, 100, 3]

Parcel 3 arrives with tops 4 and 100 and goes far. Parcel 99 then arrives with tops 4 and 3 and goes near, and parcel 2 arrives with tops 99 and 3 and goes near.

Constraints

n == weights.length
3 <= n <= 50
1 <= weights[i] <= 100
The weights are all different.

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 split_parcels(weights: list[int]) -> list[int]:

Java

public int[] splitParcels(int[] weights)

The intended approach

Time O(n): one comparison and one append per parcel.Space O(n) for the two trays, which together form the returned list.

Hold each tray as a list and push onto its end, so the parcel on top of a tray is the last entry of that list. Seed the two lists with the first two parcels, then walk the rest of the chute once, comparing the two last entries to decide where the parcel lands. Joining the near list to the far list gives the required reading order.

Pythonentry point: split_parcels

def split_parcels(weights):
    # O(n): the top of a tray is just the last thing pushed onto it.
    first = [weights[0]]
    second = [weights[1]]
    for i in range(2, len(weights)):
        if first[-1] > second[-1]:
            first.append(weights[i])
        else:
            second.append(weights[i])
    return first + second

The obvious version

Keep a single log of every placement as a weight paired with its tray, and for each new parcel scan the log backwards to find the most recent entry on each tray before deciding. Filter the log twice at the end.

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_split_parcels(weights):
    log = [(weights[0], 0), (weights[1], 1)]
    for i in range(2, len(weights)):
        top_first = None
        top_second = None
        for pos in range(len(log) - 1, -1, -1):
            value, label = log[pos]
            if label == 0 and top_first is None:
                top_first = value
            if label == 1 and top_second is None:
                top_second = value
            if top_first is not None and top_second is not None:
                break
        if top_first > top_second:
            log.append((weights[i], 0))
        else:
            log.append((weights[i], 1))
    out = [v for v, label in log if label == 0]
    out += [v for v, label in log if label == 1]
    return out

How this problem was checked

Reference solution executed against 9 test cases — 9 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