0574EasyMath

Balanced Batch Size

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 fastener plant describes a batch size as balanced when the batch can be rebuilt exactly from its own smaller shares.

A share of num is a positive whole number, strictly less than num, that goes into num leaving nothing over. Add up every share of num. When that running total lands on num itself, the batch size is balanced.

Given the batch size num, return true when it is balanced and false when it is not.

Examples

Example 1

Input: num = 496
Output: true

The shares of 496 are 1, 2, 4, 8, 16, 31, 62, 124 and 248, and they add up to 496, so the batch size is balanced.

Example 2

Input: num = 500
Output: false

The shares of 500 are 1, 2, 4, 5, 10, 20, 25, 50, 100, 125 and 250, which add up to 592. That total is not 500.

Example 3

Input: num = 1
Output: false

1 has no share at all, since a share must be a positive whole number below 1. An empty total is 0, which is not 1.

Constraints

1 <= num <= 10^8

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 check_perfect_number(num: int) -> bool:

Java

public boolean checkPerfectNumber(int num)

The intended approach

Time O(sqrt(num)) — one loop up to the square root of num.Space O(1) — only the running total and the loop counter.

Divisors come in pairs: if `d` goes into `num` then so does `num / d`, and one member of each pair is no larger than the square root. So start the running total at 1, walk `d` from 2 up to the square root, and whenever `d` divides `num` add both `d` and its partner, taking care not to add a square root twice. `num` itself is excluded because the total starts at 1 rather than at `1 + num`. Compare the total against `num`.

Pythonentry point: check_perfect_number

def check_perfect_number(num):
    # O(sqrt(num)) time, O(1) space: every divisor below the square root is
    # paired with the partner divisor above it, so one walk up to the square
    # root reaches all of them. The number itself is never added.
    if num < 2:
        return False
    total = 1
    d = 2
    while d * d <= num:
        if num % d == 0:
            total += d
            partner = num // d
            if partner != d:
                total += partner
        d += 1
    return total == num

The obvious version

Try every candidate from 1 up to `num - 1`, add the ones that divide `num` with no remainder, and compare the total against `num`.

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_check_perfect_number(num):
    total = 0
    for d in range(1, num):
        if num % d == 0:
            total += d
    return total == num

How this problem was checked

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