Distribute Money to Maximum Children - Practice Coding Problems

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

Understanding the Visualization

Constraints

Everyone gets ≥$1, nobody gets $4, all money distributed

Strategy

Give minimum first, then maximize $8 recipients

Result

Maximum number of children with exactly $8

Key Takeaway

🎯 Key Insight: Give everyone the minimum $1, then use excess money to upgrade as many as possible to $8 while avoiding the forbidden $4 amount

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

Approach	Time	Space	Notes
✓ Mathematical Approach	O(1)	O(1)	Use mathematical reasoning to directly compute the maximum number of $8 recipients
Try All Distributions	O(money^children)	O(children)	Generate all possible money distributions and find maximum $8 recipients

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;
    }
    
    int excess = money - children;
    int maxEights = excess / 7;
    if (maxEights > children) {
        maxEights = children;
    }
    
    int remainingMoney = excess - maxEights * 7;
    int remainingChildren = children - maxEights;
    
    if (remainingChildren == 1 && remainingMoney == 3) {
        if (maxEights > 0) {
            maxEights--;
        } else {
            return -1;
        }
    }
    
    return maxEights;
}

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

✓ 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

Mathematical Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler