1048EasyArrayMath

Weights That Balance Around Nothing

Tracked in this browser only

Trains the technique from

LeetCode 1304Find N Unique Integers Sum up to Zero

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.

Choose n different whole numbers, positive, negative or nothing at all, that add up to nothing.

Return them in increasing order. Where several choices work, return the one whose numbers are as large as they can be, compared from the front: its first number is the largest any valid choice can start with, then its second is the largest given that, and so on.

Examples

Example 1

Input: n = 4
Output: [-2, -1, 1, 2]

Two pairs of opposites, taken at the smallest sizes going, so one against minus one and two against minus two.

Example 2

Input: n = 7
Output: [-3, -2, -1, 0, 1, 2, 3]

Three pairs of opposites use six of the seven numbers, and the one left over has to be nothing, since everything else already cancels.

Example 3

Input: n = 2
Output: [-1, 1]

A single pair of opposites, and the smallest sizes going are one and minus one.

Constraints

1 <= n <= 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 sum_zero(n: int) -> list[int]:

Java

public int[] sumZero(int n)

The intended approach

Time O(n) to write the list out.Space O(n) for the list.

Pairing a number with its opposite contributes nothing to the total, so pairs are free. Take as many pairs as fit, which is half of `n` rounded down, using the smallest sizes going: one against minus one, two against minus two, and so on. With `n` odd one number is left over, and it has to be nothing itself, since everything else already cancels. That choice is also the one asked for. The first number cannot be larger than minus half of `n` rounded down: with fewer negatives than that, the positives above them could not be brought down to nothing while staying distinct. Given the first number, the same argument fixes the second, and so on, so the pairs of smallest size are forced. Writing the list straight out in increasing order takes one pass and no sorting.

Pythonentry point: sum_zero

def sum_zero(n):
    half = n // 2
    out = []
    for step in range(half, 0, -1):
        out.append(-step)
    if n % 2:
        out.append(0)
    for step in range(1, half + 1):
        out.append(step)
    return out

The obvious version

Search for it. Any workable choice keeps its numbers between minus `n` and `n`, since reaching further out only makes the first number smaller and so the choice worse. So run through every set of `n` different numbers from that range, keep those adding to nothing, and take whichever compares largest from the front. Costs the sets rather than a direct construction.

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_sum_zero(n):
    from itertools import combinations
    best = None
    for combo in combinations(range(-n, n + 1), n):
        total = 0
        for value in combo:
            total += value
        if total:
            continue
        values = list(combo)
        if best is None or values > best:
            best = values
    return best

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