Distribute Money to Maximum Children

Distribute Money to Maximum Children - Problem

Math Greedy Easy

You are given an integer money denoting the amount of money (in dollars) that you have and another integer children denoting the number of children that you must distribute the money to.

You have to distribute the money according to the following rules:

All money must be distributed.
Everyone must receive at least 1 dollar.
Nobody receives 4 dollars.

Return the maximum number of children who may receive exactly 8 dollars if you distribute the money according to the aforementioned rules. If there is no way to distribute the money, return -1.

Input & Output

Example 1 — Basic Case

$ Input: money = 20, children = 3

› Output: 1

💡 Note: Optimal distribution is [1, 8, 11]. One child gets exactly $8. We can't give two children $8 each because that would leave $4 for the third child, which violates the constraint.

Example 2 — Impossible Case

$ Input: money = 4, children = 2

› Output: -1

💡 Note: We have $4 for 2 children. If we give each child at least $1, we need at least $2. The remaining $2 could be distributed as [1, 3] or [2, 2], but we cannot avoid giving someone exactly $4 if we try [0, 4], and $0 violates the minimum constraint.

Example 3 — All Get $8

$ Input: money = 24, children = 3

› Output: 3

💡 Note: We can distribute as [8, 8, 8]. All three children get exactly $8, and no constraints are violated.

Constraints

1 ≤ children ≤ 50
1 ≤ money ≤ 200

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 M Microsoft 15 f Meta 12

The key insight is to use mathematical reasoning: give everyone $1 first, then upgrade as many as possible to $8 using the excess money. The optimal approach calculates this directly in O(1) time by finding excess money divided by 7 (the additional amount needed per $8 recipient), while handling the edge case where remaining money would create a forbidden $4 recipient. Time: O(1), Space: O(1)

Common Approaches

✓ Mathematical Approach

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

Calculate minimum money needed for basic distribution, then determine how many children can be upgraded to receive $8 while maintaining constraints.

Try All Distributions

⏱️ Time: O(money^children) Space: O(children)

Try every possible way to distribute money among children, checking if distribution satisfies all constraints, then count maximum children with exactly $8.

Mathematical Approach — Algorithm Steps

Check if distribution is possible (money ≥ children)
Calculate excess money after giving $1 to each child
Determine maximum children who can get $8 (need $7 extra each)
Handle edge cases where remaining money would create a $4 recipient

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Case

Give $1 to each child (minimum requirement)

Calculate

Find excess money and how many can get $8

Edge Check

Avoid creating a $4 recipient

Code -

solution.c — C

#include <stdio.h>

int solution(int money, int children) {
    if (money < children) {
        return -1;
    }
    
    // Try to give as many children $8 as possible
    for (int eights = children; eights >= 0; eights--) {
        int remainingMoney = money - eights * 8;
        int remainingChildren = children - eights;
        
        // Check if we can distribute remaining money to remaining children
        if (remainingChildren == 0) {
            // All children get $8, check if money is exactly right
            if (remainingMoney == 0) {
                return eights;
            } else {
                continue;
            }
        }
        
        // Each remaining child needs at least $1
        if (remainingMoney < remainingChildren) {
            continue;
        }
        
        // Check if any remaining child would get exactly $4
        if (remainingMoney == remainingChildren * 4) {
            continue;
        }
        
        // Check if distributing remaining money is possible
        if (remainingChildren == 1) {
            // One child gets all remaining money
            if (remainingMoney != 4) {
                return eights;
            }
        } else {
            // Multiple children - we can always distribute to avoid $4
            return eights;
        }
    }
    
    return -1;
}

int main() {
    int money, children;
    scanf("%d", &money);
    scanf("%d", &children);
    printf("%d\n", solution(money, children));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Simple arithmetic calculations without loops

✓ Linear Growth

Space Complexity

O(1)

Only uses a few integer variables

⚡ Linearithmic 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

Mathematical Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler