Count Largest Group

Count Largest Group - Problem

You are given an integer n.

We need to group the numbers from 1 to n according to the sum of their digits. For example, the numbers 14 and 5 belong to the same group (digit sum = 5), whereas 13 and 3 belong to different groups (digit sums 4 and 3).

Return the number of groups that have the largest size, i.e. the maximum number of elements.

Input & Output

Example 1 — Basic Case

$ Input: n = 13

› Output: 4

💡 Note: Numbers 1-13 grouped by digit sum: {1:[1,10], 2:[2,11], 3:[3,12], 4:[4,13], 5:[5], 6:[6], 7:[7], 8:[8], 9:[9]}. Groups with digit sum 1,2,3,4 each have 2 elements (maximum). Four groups have this maximum size of 2.

Example 2 — Small Input

$ Input: n = 2

› Output: 2

💡 Note: Numbers: {1:[1], 2:[2]}. Each group has size 1, which is the maximum. Two groups have this maximum size.

Example 3 — Larger Input

$ Input: n = 15

› Output: 6

💡 Note: Groups: {1:[1,10], 2:[2,11], 3:[3,12], 4:[4,13], 5:[5,14], 6:[6,15], 7:[7], 8:[8], 9:[9]}. Maximum group size is 2, and 6 groups have this size.

Constraints

1 ≤ n ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to group numbers by their digit sum and find how many groups have the maximum size. Best approach uses a hash map to count group frequencies efficiently. Time: O(n×d), Space: O(k) where d is digits per number and k is unique digit sums.

Common Approaches

✓ Brute Force with Array

⏱️ Time: O(n × d) Space: O(s)

Calculate digit sum for each number from 1 to n, use an array to count group sizes, then iterate through the array to find the maximum count and how many groups have that count.

Hash Map Frequency Count

⏱️ Time: O(n × d) Space: O(k)

Calculate digit sum for each number and use a hash map to count how many numbers have each digit sum. Then find the maximum count and determine how many digit sums achieve this maximum.

Brute Force with Array — Algorithm Steps

Calculate digit sum for each number 1 to n
Use array index as digit sum, increment count
Find maximum group size
Count how many groups have maximum size

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Digit Sums

For each number 1 to n, calculate sum of digits

Count Groups

Use array index as digit sum, increment count

Find Maximum

Find largest group size and count occurrences

Code -

solution.c — C

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

int solution(int n) {
    // Array to count group sizes
    int maxDigitSum = 100; // Conservative upper bound
    int groupCounts[maxDigitSum + 1];
    memset(groupCounts, 0, sizeof(groupCounts));
    
    // Calculate digit sum for each number and count groups
    for (int num = 1; num <= n; num++) {
        int digitSum = 0;
        int temp = num;
        while (temp > 0) {
            digitSum += temp % 10;
            temp /= 10;
        }
        groupCounts[digitSum]++;
    }
    
    // Find maximum group size
    int maxSize = 0;
    for (int i = 0; i <= maxDigitSum; i++) {
        if (groupCounts[i] > maxSize) {
            maxSize = groupCounts[i];
        }
    }
    
    // Count how many groups have maximum size
    int count = 0;
    for (int i = 0; i <= maxDigitSum; i++) {
        if (groupCounts[i] == maxSize) {
            count++;
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × d)

n iterations, each taking O(d) time to calculate digit sum where d is number of digits

✓ Linear Growth

Space Complexity

O(s)

Array of size s where s is maximum possible digit sum (around 9×log₁₀(n))

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

423 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 with Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler