Distribute Candies Among Children I

Distribute Candies Among Children I - Problem

You are given two positive integers n and limit.

Return the total number of ways to distribute n candies among 3 children such that no child gets more than limit candies.

Each child can receive 0 or more candies, and the sum of all candies distributed must equal n.

Input & Output

Example 1 — Basic Case

$ Input: n = 5, limit = 2

› Output: 3

💡 Note: Valid distributions: (0,2,3) is invalid since 3>2, but (1,2,2), (2,1,2), (2,2,1) are valid. Actually there are 3 valid ways total.

Example 2 — Small Values

$ Input: n = 3, limit = 3

› Output: 10

💡 Note: With high limit, all combinations work: (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 — Tight Constraint

$ Input: n = 4, limit = 1

› Output: 0

💡 Note: Impossible: need to distribute 4 candies but each child can only get max 1, so 3×1 = 3 < 4

Constraints

1 ≤ n ≤ 50
1 ≤ limit ≤ 50

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

This is a combinatorics problem asking to count the number of ways to distribute n candies among 3 children with an upper limit constraint. The brute force approach uses nested loops to try all possibilities in O(n²) time. The optimal mathematical approach uses the inclusion-exclusion principle to count valid distributions in O(1) time. Key insight: transform the constrained stars-and-bars problem using combinatorial formulas.

Common Approaches

✓ Inclusion-Exclusion Principle

⏱️ Time: O(1) Space: O(1)

Apply the inclusion-exclusion principle to count the number of non-negative integer solutions to x₁ + x₂ + x₃ = n where each xᵢ ≤ limit. Start with unrestricted count, then subtract overcounting cases.

Triple Nested Loop

⏱️ Time: O(n²) Space: O(1)

Iterate through all possible values for first two children (0 to limit), calculate the third child's candies, and count valid distributions where all constraints are satisfied.

Inclusion-Exclusion Principle — Algorithm Steps

Step 1: Count all ways without upper limit using stars and bars: C(n+2, 2)
Step 2: Subtract cases where at least one child exceeds limit
Step 3: Add back cases where at least two children exceed limit
Step 4: Subtract cases where all three children exceed limit

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with All

Count all ways without upper limit using C(n+2,2)

Subtract Violations

Remove cases where children exceed limit

Add Back Overcounts

Use inclusion-exclusion to get exact count

Code -

solution.c — C

#include <stdio.h>

int combinations(int n, int k) {
    if (k > n || k < 0) return 0;
    if (k == 0 || k == n) return 1;
    if (k > n - k) k = n - k;
    int result = 1;
    for (int i = 0; i < k; i++) {
        result = result * (n - i) / (i + 1);
    }
    return result;
}

int solution(int n, int limit) {
    int total = combinations(n + 2, 2);
    
    if (n > limit) {
        total -= 3 * combinations(n - limit - 1 + 2, 2);
    }
    
    if (n > 2 * limit) {
        total += 3 * combinations(n - 2 * limit - 2 + 2, 2);
    }
    
    if (n > 3 * limit) {
        total -= combinations(n - 3 * limit - 3 + 2, 2);
    }
    
    return total;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(1)

Direct mathematical calculation using formulas

✓ Linear Growth

Space Complexity

O(1)

Only using variables for intermediate calculations

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Inclusion-Exclusion Principle — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler