Move Zeroes

Filter then pad

The direct version writes the rule almost word for word: collect every non-zero value, then add exactly enough zeroes to restore the original length.

def move_zeroes(nums: list[int]) -> list[int]:
    non_zero = [value for value in nums if value != 0]
    zero_count = len(nums) - len(non_zero)
    return non_zero + [0] * zero_count

Because that list is built from left to right, it preserves the order automatically.

Time O(n) — every value is inspected once. Space O(n) — the returned construction holds a copy of the non-zero values and the padded zeroes.

Stable write pointer

The extra list isn't carrying new information. A write pointer can mark the next slot that belongs to a non-zero value. Each survivor moves into that slot, in scan order, so the compacted prefix is always correct.

After the scan, write is also the number of non-zero values. Every remaining position belongs to the zero suffix.

def move_zeroes(nums: list[int]) -> list[int]:
    write = 0
 
    for value in nums:
        if value != 0:
            nums[write] = value
            write += 1
 
    for i in range(write, len(nums)):
        nums[i] = 0
 
    return nums

Writing only at or behind the current read position is safe: you never overwrite a value that the scan hasn't seen yet. And because survivors are written in their original scan order, stability comes for free.

Time O(n) — the scan and suffix fill together touch at most 2n positions. Space O(1) — all work happens inside the returned array.

LeetCode's version mutates the array in place and returns void; ours returns the resulting array so the judge can compare it.