Distribute Candies Among Children I - Practice Coding Problems

Distribute Candies Among Children I - Problem

Imagine you're a parent with n candies that you want to distribute fairly among your 3 children. However, you have a rule: no single child can receive more than limit candies to ensure fairness and prevent sugar overload! 🍬

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

Each child can receive 0 or more candies
No child receives more than limit candies
All n candies must be distributed

Example: If you have 5 candies and limit is 2, one valid distribution is [2, 2, 1] - giving 2 candies to the first child, 2 to the second, and 1 to the third.

Input & Output

example_1.py — Basic Distribution

$ Input: n = 5, limit = 2

› Output: 3

💡 Note: The valid distributions are: [1,2,2], [2,1,2], [2,2,1]. Each child gets at most 2 candies and all 5 candies are distributed.

example_2.py — High Limit

$ Input: n = 3, limit = 3

› Output: 10

💡 Note: Since limit ≥ n, any distribution is valid. This includes [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].

example_3.py — Edge Case

$ Input: n = 1, limit = 1

› Output: 3

💡 Note: The valid distributions are: [0,0,1], [0,1,0], [1,0,0]. Only one child gets the single candy in each case.

Visualization

Tap to expand

Understanding the Visualization

Setup

We have n total candies and each child can get at most 'limit' candies

Enumerate Child 1

Try giving 0 to min(n, limit) candies to the first child

Enumerate Child 2

For each Child 1 allocation, try all valid amounts for Child 2

Calculate Child 3

The remaining candies automatically go to Child 3

Validate

Count only if Child 3's allocation is within the limit

Key Takeaway

🎯 Key Insight: By fixing the first two children's candy counts, the third child's count is automatically determined, making this an efficient O(limit²) enumeration problem.

Time & Space Complexity

Time Complexity

⏱️

O(limit²)

We have two nested loops, each running up to 'limit' times

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and iterations

✓ Linear Space

Constraints

1 ≤ n ≤ 50
1 ≤ limit ≤ 50
All inputs are positive integers

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

This is a constrained combinatorics problem where we count valid ways to distribute candies. The brute force approach with nested loops efficiently solves this by trying all combinations in O(limit²) time, which is optimal for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(limit²)	O(1)	Try every possible combination of candies for each child

Brute Force (Triple Nested Loops) — Algorithm Steps

Loop through possible candies for child 1: 0 to min(n, limit)
For each value, loop through possible candies for child 2: 0 to min(n - child1, limit)
Calculate remaining candies for child 3: n - child1 - child2
Check if child 3's candies are within limit (≥ 0 and ≤ limit)
If valid, increment the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with count = 0, prepare to check all combinations

Child 1 Loop

Try giving 0 to min(n, limit) candies to first child

Child 2 Loop

For each child 1 value, try all valid values for child 2

Calculate Child 3

Compute remaining candies for third child

Validate

Check if child 3's allocation is within limits

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 candies for child 1
    for (int child1 = 0; child1 <= min(n, limit); child1++) {
        // Try all possible candies for child 2
        for (int child2 = 0; child2 <= min(n - child1, limit); child2++) {
            // Calculate remaining candies for child 3
            int child3 = n - child1 - child2;
            // Check if child 3's allocation 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 up to 'limit' times

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track counts and iterations

✓ Linear Space

Constraints

1 ≤ n ≤ 50
1 ≤ limit ≤ 50
All inputs are positive integers

12.8K Views

Medium Frequency

~8 min Avg. Time

340 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler