0667EasyArrayTwo PointersSimulation

Settle the Conveyor Trays

Tracked in this browser only

Trains the technique from

LeetCode 2460Apply Operations to an Array

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 conveyor carries a row of trays. counts[i] is how many parts sit in tray i, and a tray holding 0 parts is empty.

A settling run walks the row once from left to right. For each index i from 0 up to counts.length - 2, in that order, it looks at trays i and i + 1 as they stand at that moment. If both hold the same number of parts and that number is not 0, the contents of tray i + 1 are tipped into tray i, so tray i then holds twice as many parts as before and tray i + 1 becomes empty. Otherwise both trays are left alone. Every index is visited exactly once.

When the walk is over, the trays that still hold parts are pushed to the front of the row in the order they already had, and the empty trays follow them.

Return the row of tray contents after the settling run and the push.

Examples

Example 1

Input: counts = [8, 8, 5, 5, 5]
Output: [16, 10, 5, 0, 0]

At index `0` the two trays of `8` become a tray of `16` and an empty tray. At index `1` the trays hold `0` and `5`, which are different, so nothing happens. At index `2` the two trays of `5` become `10` and an empty tray. At index `3` the trays hold `0` and `5`. Pushing the loaded trays forward gives `16, 10, 5` followed by the two empties.

Example 2

Input: counts = [6, 6, 6, 6, 6, 6]
Output: [12, 12, 12, 0, 0, 0]

Indices `0`, `2` and `4` each tip a pair of `6`s into a `12`, and at indices `1` and `3` the left tray is already empty. Three loaded trays are pushed to the front.

Example 3

Input: counts = [4, 0, 4]
Output: [4, 4, 0]

No index has two equal non-empty trays side by side, so no tipping happens and only the push takes place.

Constraints

2 <= counts.length <= 2000
0 <= counts[i] <= 1000

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 settle_line(counts: list[int]) -> list[int]:

Java

public int[] settleLine(int[] counts)

The intended approach

Time O(n): two walks over the row.Space O(1) beyond the row that is returned.

Do the two stages as two walks over the same list. The first walk visits the indices in increasing order and applies the tipping rule to the live values, so a tray that was just emptied is seen as empty when it is compared with its right neighbour. The second walk keeps a write cursor at the next slot that should hold parts: every loaded tray it meets is swapped into that slot and the cursor advances, which pulls the loaded trays forward in order and pushes the empties to the tail.

Pythonentry point: settle_line

def settle_line(counts):
    # one left-to-right tipping pass, then a write cursor pulls the loaded trays forward
    n = len(counts)
    for i in range(n - 1):
        if counts[i] != 0 and counts[i] == counts[i + 1]:
            counts[i] *= 2
            counts[i + 1] = 0
    write = 0
    for read in range(n):
        if counts[read] != 0:
            counts[write], counts[read] = counts[read], counts[write]
            write += 1
    return counts

The obvious version

Copy the row, apply the tipping rule index by index, then push the loaded trays forward by repeatedly sweeping the row and swapping any empty tray with the loaded tray immediately to its right, until a full sweep finds nothing to swap.

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_settle_line(counts):
    row = list(counts)
    n = len(row)
    for i in range(n - 1):
        if row[i] != 0 and row[i] == row[i + 1]:
            row[i] = row[i] * 2
            row[i + 1] = 0
    moved = True
    while moved:
        moved = False
        for i in range(n - 1):
            if row[i] == 0 and row[i + 1] != 0:
                row[i], row[i + 1] = row[i + 1], row[i]
                moved = True
    return row

How this problem was checked

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