Distribute Candies Among Children III - Practice Coding Problems

Distribute Candies Among Children III - Problem

Math Combinatorics Hard

You're a parent with n candies to distribute fairly among your 3 children. Each child has a sweet tooth, but you want to ensure no child gets more than limit candies to avoid a sugar rush!

Your task is to find the total number of ways to distribute all n candies among the 3 children such that:

Every candy must be given to some child (no leftovers)
No child receives more than limit candies
A child can receive 0 candies (they might be satisfied already)

Example: With n = 5 candies and limit = 2, one valid distribution is (2, 2, 1) - first child gets 2, second gets 2, third gets 1.

Input & Output

example_1.py — Basic Case

$ Input: n = 5, limit = 2

› Output: 3

💡 Note: Valid distributions are: (0,2,3) - invalid since 3>2, (1,2,2), (2,1,2), (2,2,1). After checking all combinations systematically: (0,1,4) invalid, (0,2,3) invalid, (1,0,4) invalid, (1,1,3) invalid, (1,2,2) valid, (2,0,3) invalid, (2,1,2) valid, (2,2,1) valid. Total: 3 ways.

example_2.py — Small Numbers

$ Input: n = 3, limit = 3

› Output: 10

💡 Note: With no effective limit constraint (since max any child can get is 3), this becomes a standard stars and bars problem. All possible distributions: (0,0,3), (0,1,2), (0,2,1), (0,3,0), (1,0,2), (1,1,1), (1,2,0), (2,0,1), (2,1,0), (3,0,0). Total: 10 ways.

example_3.py — Edge Case

$ Input: n = 1, limit = 1

› Output: 3

💡 Note: With only 1 candy and limit 1, each child can receive either 0 or 1 candy. Valid distributions: (1,0,0), (0,1,0), (0,0,1). Each child gets exactly 1 candy in one of the distributions. Total: 3 ways.

Constraints

1 ≤ n ≤ 10⁶
1 ≤ limit ≤ 10⁶
Each child can receive 0 to limit candies
All n candies must be distributed

Visualization

Tap to expand

Understanding the Visualization

Stars and Bars Setup

Imagine n stars (candies) and 2 bars to create 3 groups (children)

Count Total Ways

Without restrictions: C(n+2, 2) total arrangements

Apply Constraints

Use inclusion-exclusion to remove invalid distributions

Final Count

Result gives valid ways respecting the limit constraint

Key Takeaway

🎯 Key Insight: The inclusion-exclusion principle elegantly handles constrained counting problems by systematically removing invalid cases from the total count.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

This problem is solved optimally using the inclusion-exclusion principle with stars and bars combinatorics. The key insight is to first count all unrestricted ways to distribute n candies among 3 children using C(n+2, 2), then systematically subtract cases where constraints are violated. The mathematical approach achieves O(1) time complexity compared to the brute force O(limit²) solution.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(limit²)	O(1)	Try all possible distributions using nested loops for the first two children
Mathematical Combinatorics (Optimal)	O(1)	O(1)	Use inclusion-exclusion principle with stars and bars combinatorics

Brute Force (Nested Loops) — Algorithm Steps

Loop through all possible candies (0 to limit) for child 1
For each choice of child 1, loop through all possible candies for child 2
Calculate remaining candies for child 3
Check if child 3's portion is valid (>= 0 and <= limit)
Count all valid distributions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with child1 = 0, child2 = 0

Iterate child2

For each child1 value, try all valid child2 values

Calculate child3

child3 gets the remaining candies: n - child1 - child2

Validate

Check if child3's portion is between 0 and limit

Code -

solution.c — C

#include <stdio.h>

int min(int a, int b) {
    return (a < b) ? a : b;
}

int distributeCandies(int n, int limit) {
    int count = 0;
    // Try all possible distributions for first two children
    for (int child1 = 0; child1 <= min(n, limit); child1++) {
        for (int child2 = 0; child2 <= min(n - child1, limit); child2++) {
            int child3 = n - child1 - child2;
            // Check if child3's share is valid
            if (child3 >= 0 && child3 <= limit) {
                count++;
            }
        }
    }
    return count;
}

int main() {
    int n, limit;
    scanf("%d %d", &n, &limit);
    printf("%d\n", distributeCandies(n, limit));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(limit²)

We have two nested loops, each running from 0 to limit, giving us O(limit²) iterations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and iterations

✓ Linear Space

21.1K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler