Maximum Number of Balls in a Box - Practice Coding Problems

Maximum Number of Balls in a Box - Problem

Imagine you're working at a magical ball factory! 🏭 You have n balls numbered consecutively from lowLimit to highLimit (inclusive), and an infinite number of boxes numbered from 1 to infinity.

Your job is to sort these balls into boxes using a special rule: each ball goes into the box whose number equals the sum of the ball's digits.

Examples of the sorting rule:

Ball 321 → Box 3 + 2 + 1 = 6
Ball 10 → Box 1 + 0 = 1
Ball 999 → Box 9 + 9 + 9 = 27

After sorting all balls, you need to find which box contains the maximum number of balls and return that count.

Goal: Return the number of balls in the most crowded box!

Input & Output

example_1.py — Small Range

$ Input: lowLimit = 1, highLimit = 10

› Output: 2

💡 Note: Balls 1→box 1, 2→box 2, 3→box 3, 4→box 4, 5→box 5, 6→box 6, 7→box 7, 8→box 8, 9→box 9, 10→box 1. Box 1 has balls [1,10], so count is 2.

example_2.py — Medium Range

$ Input: lowLimit = 5, highLimit = 15

› Output: 2

💡 Note: Balls: 5→box 5, 6→box 6, 7→box 7, 8→box 8, 9→box 9, 10→box 1, 11→box 2, 12→box 3, 13→box 4, 14→box 5, 15→box 6. Box 5 has balls [5,14] and box 6 has balls [6,15], both with count 2.

example_3.py — Single Ball

$ Input: lowLimit = 19, highLimit = 19

› Output: 1

💡 Note: Only one ball (19) which goes to box 1+9=10. That box contains 1 ball, so the answer is 1.

Visualization

Tap to expand

Understanding the Visualization

Scan Ball Number

Each ball passes through a scanner that reads its number

Calculate Digit Sum

The system calculates the sum of all digits in the ball number

Route to Box

Ball is automatically routed to the box matching its digit sum

Update Counter

Box counter increments and system tracks if this is the new maximum

Key Takeaway

🎯 Key Insight: Process each ball exactly once, immediately updating both the frequency count and maximum tracker for optimal O(n×d) performance!

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

Where n is the number of balls (highLimit - lowLimit + 1) and d is the average number of digits per number. Each ball is processed exactly once.

✓ Linear Growth

Space Complexity

O(k)

Where k is the number of unique digit sums (at most 45 for 5-digit numbers). We store one entry per unique box.

✓ Linear Space

Constraints

1 ≤ lowLimit ≤ highLimit ≤ 10⁵
Ball numbers are consecutive integers
Box numbers start from 1 (minimum possible digit sum)
Maximum possible digit sum is 45 (for number 99999)

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a one-pass hash table approach with O(n×d) time complexity. We iterate through each ball exactly once, calculate its digit sum, and maintain a frequency counter for each box. The key insight is that we can track the maximum count as we build the frequency map, eliminating the need for a separate pass to find the maximum.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Calculation)	O(n × k × d)	O(1)	Recalculate digit sums multiple times for each comparison
One-Pass Hash Table (Optimal)	O(n × d)	O(k)	Calculate each digit sum once and count frequencies in a single pass

Brute Force (Nested Calculation) — Algorithm Steps

For each ball number, calculate its digit sum
For each possible box (digit sum value), count how many balls belong to it
This requires recalculating digit sums multiple times
Return the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Box 1

Go through all balls, calculate digit sum for each, count matches for box 1

Check Box 2

Go through all balls again, recalculate digit sums, count matches for box 2

Repeat Process

Continue for all possible boxes, recalculating sums each time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int digitSum(int num) {
    int total = 0;
    while (num > 0) {
        total += num % 10;
        num /= 10;
    }
    return total;
}

int countBallsInBoxes(int lowLimit, int highLimit) {
    int maxCount = 0;
    // Try all possible digit sums
    for (int box = 1; box <= 45; box++) {
        int count = 0;
        for (int ball = lowLimit; ball <= highLimit; ball++) {
            if (digitSum(ball) == box) {
                count++;
            }
        }
        if (count > maxCount) {
            maxCount = count;
        }
    }
    return maxCount;
}

int main() {
    int lowLimit, highLimit;
    scanf("[%d,%d]", &lowLimit, &highLimit);
    
    printf("%d\n", countBallsInBoxes(lowLimit, highLimit));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k × d)

Where n is the number of balls, k is the number of unique digit sums, and d is the average number of digits. We recalculate digit sums multiple times.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

Constraints

1 ≤ lowLimit ≤ highLimit ≤ 10⁵
Ball numbers are consecutive integers
Box numbers start from 1 (minimum possible digit sum)
Maximum possible digit sum is 45 (for number 99999)

28.4K Views

Medium Frequency

~15 min Avg. Time

980 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 (Nested Calculation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler