Count Elements With Maximum Frequency - Practice Coding Problems

Count Elements With Maximum Frequency - Problem

You are given an array nums consisting of positive integers.

Return the total frequencies of elements in nums such that those elements all have the maximum frequency.

The frequency of an element is the number of occurrences of that element in the array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,3,2,3,3]

› Output: 3

💡 Note: Element 3 appears 3 times (maximum frequency). Elements 1 and 2 appear 1 time each. Total frequency of elements with maximum frequency = 3.

Example 2 — Multiple Elements with Same Max Frequency

$ Input: nums = [1,1,2,2,3]

› Output: 4

💡 Note: Elements 1 and 2 both appear 2 times (maximum frequency). Element 3 appears 1 time. Total frequency of elements with maximum frequency = 2 + 2 = 4.

Example 3 — All Elements Same Frequency

$ Input: nums = [1,2,3]

› Output: 3

💡 Note: All elements appear 1 time (maximum frequency). Total frequency = 1 + 1 + 1 = 3.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array of positive integers with varying frequencies

Count Frequencies

Build frequency map and find maximum frequency

Sum Maximum Frequencies

Add up frequencies of elements with maximum count

Key Takeaway

🎯 Key Insight: Track maximum frequency dynamically while building frequency map for optimal O(n) solution

Asked in

a Amazon 25 G Google 18 M Microsoft 15

The key insight is to track maximum frequency while building a frequency map. Best approach uses single-pass hash map that dynamically updates the result as maximum frequency changes. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Count frequency of each element separately, find max, then sum frequencies of max elements
Two-Pass Hash Map	O(n)	O(n)	First pass builds frequency map, second pass finds max frequency and sums result
Single-Pass Optimized	O(n)	O(n)	Track maximum frequency while building frequency map in single pass

Brute Force — Algorithm Steps

Step 1: Count frequency of each unique element by scanning array
Step 2: Find the maximum frequency among all elements
Step 3: Sum frequencies of elements that have maximum frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unique Elements

Scan array to find all unique values

Count Each Element

For each unique element, scan entire array to count occurrences

Sum Maximum Frequencies

Add up frequencies of elements with maximum count

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int maxFreq = 0;
    int result = 0;
    
    // Find all unique elements first
    int uniqueElements[1000];
    int uniqueCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < uniqueCount; j++) {
            if (uniqueElements[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            uniqueElements[uniqueCount++] = nums[i];
        }
    }
    
    // Count frequency of each unique element
    int frequencies[1000];
    for (int i = 0; i < uniqueCount; i++) {
        int count = 0;
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] == uniqueElements[i]) {
                count++;
            }
        }
        frequencies[i] = count;
        if (count > maxFreq) {
            maxFreq = count;
        }
    }
    
    // Sum frequencies of elements with maximum frequency
    for (int i = 0; i < uniqueCount; i++) {
        if (frequencies[i] == maxFreq) {
            result += frequencies[i];
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each unique element, we scan the entire array to count frequency

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track counts and maximum

✓ Linear Space

12.5K Views

Medium Frequency

~8 min Avg. Time

485 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler