Count Largest Group - Practice Coding Problems

Count Largest Group - Problem

You are given an integer n, and your task is to organize numbers from 1 to n into groups based on an interesting property: the sum of their digits.

For example, consider n = 24:

Number 14 has digit sum: 1 + 4 = 5
Number 23 has digit sum: 2 + 3 = 5
Number 5 has digit sum: 5

So numbers 14, 23, and 5 would all belong to the same group (digit sum = 5).

Your goal is to find how many groups have the maximum size. In other words, find the largest group size, then count how many groups have exactly that many elements.

Input: An integer n (1 ≤ n ≤ 10⁴)

Output: The number of groups that contain the maximum number of elements

Input & Output

example_1.py — Basic case

$ Input: n = 13

› Output: 4

💡 Note: Groups: {1:[1,10]}, {2:[2,11]}, {3:[3,12]}, {4:[4,13]}, {5:[5]}, {6:[6]}, {7:[7]}, {8:[8]}, {9:[9]}. All groups except {5},{6},{7},{8},{9} have size 2, but these 5 groups have size 1. So there are 4 groups with the maximum size of 2.

example_2.py — Larger case

$ Input: n = 2

› Output: 2

💡 Note: Groups: {1:[1]}, {2:[2]}. Both groups have size 1, which is the maximum. So answer is 2.

example_3.py — Edge case

$ Input: n = 1

› Output: 1

💡 Note: Only one group: {1:[1]} with size 1. There's 1 group with the maximum size of 1.

Constraints

1 ≤ n ≤ 10⁴
All numbers are positive integers
Maximum digit sum is 36 (for 9999)

Visualization

Tap to expand

Understanding the Visualization

Scan Books

Go through each book and calculate the digit sum of its page count

Place on Shelves

Group books with the same digit sum together on the same shelf

Find Fullest Shelves

Identify which shelves have the most books and count how many such shelves exist

Key Takeaway

🎯 Key Insight: Use a hash table to count frequencies in one pass, then find how many groups share the maximum frequency.

Asked in

a Amazon 15 ⊞ Microsoft 8 G Google 5

The optimal solution uses a hash table to count the frequency of each digit sum in O(n) time. We iterate through numbers 1 to n once, calculate each number's digit sum, and build a frequency map. Then we find the maximum frequency and count how many digit sums have that frequency.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count Each Group Separately)	O(n × k)	O(1)	For each possible digit sum, count how many numbers have that sum
One-Pass Hash Table (Optimal)	O(n × d)	O(k)	Build frequency map of digit sums in one pass, then find groups with maximum size

Brute Force (Count Each Group Separately) — Algorithm Steps

Generate all possible digit sums (1 to 36)
For each digit sum, iterate through 1 to n counting matches
Track the maximum group size found
Count how many groups have the maximum size

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Sum=1

Count numbers 1,10,100... with digit sum 1

Check Sum=2

Count numbers 2,11,20... with digit sum 2

Find Maximum

Identify which group sizes are largest

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 countLargestGroup(int n) {
    int groupSizes[36] = {0};
    int groupCount = 0;
    
    for (int targetSum = 1; targetSum <= 36; targetSum++) {
        int count = 0;
        for (int i = 1; i <= n; i++) {
            if (digitSum(i) == targetSum) {
                count++;
            }
        }
        if (count > 0) {
            groupSizes[groupCount++] = count;
        }
    }
    
    if (groupCount == 0) return 0;
    
    int maxSize = groupSizes[0];
    for (int i = 1; i < groupCount; i++) {
        if (groupSizes[i] > maxSize) {
            maxSize = groupSizes[i];
        }
    }
    
    int result = 0;
    for (int i = 0; i < groupCount; i++) {
        if (groupSizes[i] == maxSize) {
            result++;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Where k is max possible digit sum (36). For each of k sums, we check all n numbers

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track counts and maximum

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force (Count Each Group Separately) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler