0154EasyArrayPrefix Sum

Beam Balance Station

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.

A steel beam rests on a row of posts. The array loads gives the signed load measured at each post, listed in order along the beam. A negative reading means that post is being pulled upward rather than pressed down.

A post counts as a balance station when the readings on every post listed before it total exactly what the readings on every post listed after it total. The reading on the balance station itself belongs to neither side and is skipped. A post at either end of the row is still eligible, since a side with no posts on it totals zero.

Return the index of the earliest balance station on the beam. When several posts balance the beam, the smallest such index is the answer. When no post balances it, return -1.

Examples

Example 1

Input: loads = [5, -2, 9, 4, -1]
Output: 2

Before index 2 the readings 5 and -2 total 3, and after it the readings 4 and -1 also total 3. The load of 9 on the station itself is skipped.

Example 2

Input: loads = [8, -3, 5]
Output: -1

No post splits the rest of the beam into two equally loaded sides, so the answer is -1.

Example 3

Input: loads = [0, 0, 0]
Output: 0

Every post balances the beam here, so the earliest index wins.

Constraints

1 <= loads.length <= 10^4
-1000 <= loads[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 balance_station(loads: list[int]) -> int:

Java

public int balanceStation(int[] loads)

The intended approach

Time O(n)Space O(1) beyond the input, since only the grand total and one running total are kept

Total the whole beam once. Then sweep left to right holding the running total of everything already passed; the load behind the current post is the grand total minus that running total minus the current reading. The first post where the two sides match is the answer, so the leftmost tie-break falls out of the sweep order for free.

Pythonentry point: balance_station

def balance_station(loads):
    # one pass after the total: O(n) time, O(1) extra space
    total = sum(loads)
    ahead = 0
    for i, load in enumerate(loads):
        # readings behind post i, without post i itself
        behind = total - ahead - load
        if ahead == behind:
            return i
        ahead += load
    return -1

The obvious version

For every post, re-add the two sides from scratch with slicing and compare them. O(n^2).

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_balance_station(loads):
    n = len(loads)
    for i in range(n):
        if sum(loads[:i]) == sum(loads[i + 1:]):
            return i
    return -1

How this problem was checked

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