0407EasyArray

Bonus Sheet Leaders

Tracked in this browser only

Trains the technique from

LeetCode 1431Kids With the Greatest Number of Candies

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 collectors' club keeps a register of how many stamps each member owns, with stamps[i] the count held by member i. One bonus sheet carrying bonus further stamps is up for grabs.

Ask the same question of every member in turn: if this member alone were handed the whole bonus sheet, would their new count be at least as large as the count every other member holds today? Ties count as yes, and more than one member can answer yes.

Return a list answer of the same length as stamps, where answer[i] is true when member i answers yes and false when they do not. Every question is judged against the register as it stands, since the sheet is only ever handed out hypothetically.

Examples

Example 1

Input: stamps = [6,9,4,9], bonus = 2
Output: [false,true,false,true]

The largest holding on the register is 9. Member 0 would reach 8 and member 2 would reach 6, both short of 9. Members 1 and 3 would each reach 11.

Example 2

Input: stamps = [7,7], bonus = 1
Output: [true,true]

Either member would reach 8, which clears the other member's 7.

Example 3

Input: stamps = [3,20,5], bonus = 17
Output: [true,true,true]

Member 0 would reach exactly 20, which ties the largest holding and so counts as yes. Member 1 would reach 37 and member 2 would reach 22.

Example 4

Input: stamps = [50,10,30], bonus = 19
Output: [true,false,false]

The largest holding is 50. Member 1 would reach 29 and member 2 would reach 49, both short of it, while member 0 would reach 69.

Example 5

Input: stamps = [8,5], bonus = 3
Output: [true,true]

Member 1 would reach exactly 8, level with member 0's holding, and a tie answers yes.

Constraints

n == stamps.length
2 <= n <= 100
1 <= stamps[i] <= 100
1 <= bonus <= 50

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 kids_with_candies(stamps: list[int], bonus: int) -> list[bool]:

Java

public List<Boolean> kidsWithCandies(int[] stamps, int bonus)

The intended approach

Time O(n)Space O(n) for the returned list of flags

Every question compares against the same figure, the largest holding on the register, because a member who clears that figure clears all the others too, and a member who does not clear it fails against whoever holds it. Find that largest holding in one pass, then emit one flag per member for whether their count plus the bonus reaches it.

Pythonentry point: kids_with_candies

def kids_with_candies(stamps, bonus):
    # Time O(n): one pass to find the largest holding, one to build the flags.
    # Space O(n) for the returned list; O(1) beyond what is returned.
    best = stamps[0]
    for value in stamps:
        if value > best:
            best = value
    flags = []
    for value in stamps:
        flags.append(value + bonus >= best)
    return flags

The obvious version

For each member, loop over every other member and check the boosted count against each of their holdings one at a time.

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_kids_with_candies(stamps, bonus):
    out = []
    for i in range(len(stamps)):
        holds = True
        for j in range(len(stamps)):
            if j != i and stamps[i] + bonus < stamps[j]:
                holds = False
        out.append(holds)
    return out

How this problem was checked

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