Count Elements With Maximum Frequency - Practice Coding Problems

Count Elements With Maximum Frequency - Problem

You're given an array nums of positive integers, and your task is to find elements that appear most frequently, then sum up their total occurrences.

Here's how it works: First, determine the maximum frequency (the highest number of times any element appears). Then, find all elements that appear exactly this many times, and return the sum of all their frequencies.

Example: If array [1,2,2,3,1,4] has elements 1 and 2 each appearing 2 times (maximum frequency), while others appear once, the answer is 2 + 2 = 4.

Input & Output

example_1.py — Basic case with multiple max frequencies

$ Input: [1,2,2,3,1,4]

› Output: 4

💡 Note: Elements 1 and 2 both appear 2 times (maximum frequency). Sum = 2 + 2 = 4

example_2.py — Single element with max frequency

$ Input: [1,2,3,4,5]

› Output: 5

💡 Note: All elements appear once (maximum frequency = 1). Sum = 1 + 1 + 1 + 1 + 1 = 5

example_3.py — One dominant element

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

› Output: 3

💡 Note: Element 1 appears 3 times (maximum frequency). Only element 1 has max frequency. Sum = 3

Visualization

Tap to expand

Understanding the Visualization

Initialize Tracking

Start with empty frequency map, max_freq=0, count=0

Process Each Element

Update frequency and check if it becomes new maximum

Update Maximum Tracking

When frequency exceeds max, reset count; when equal, increment count

Calculate Result

Return max_freq × count (total frequencies of most frequent elements)

Key Takeaway

🎯 Key Insight: By tracking the maximum frequency and count of elements with that frequency simultaneously during our single pass, we eliminate the need for multiple passes through the data, achieving optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(n)

Hash table stores at most n unique elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All elements are positive integers

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal one-pass hash table approach efficiently solves this problem by tracking frequencies and the maximum frequency simultaneously. As we build our frequency map, we dynamically update the maximum frequency and count of elements with that frequency, eliminating the need for multiple passes through the data.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	Count frequency of each element using nested loops, find max frequency, then sum frequencies
One-Pass Hash Table (Optimal)	O(n)	O(n)	Track frequencies and max frequency simultaneously in a single pass
Two-Pass Hash Table	O(n)	O(n)	First pass builds frequency map, second pass finds max frequency and sums result

Brute Force (Nested Loops) — Algorithm Steps

Get all unique elements from the array
For each unique element, count its occurrences in the array
Find the maximum frequency among all elements
Sum frequencies of all elements that have the maximum frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Unique Elements

Extract all unique elements from the array

Count Each Element

For each unique element, scan the entire array to count occurrences

Find Maximum Frequency

Determine the highest frequency among all elements

Sum Max Frequencies

Add up frequencies of all elements that have the maximum frequency

Code -

solution.c — C

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

int maxFrequencyElements(int* nums, int numsSize) {
    // Count frequency of each element (assuming elements are small positive integers)
    int maxVal = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int* freq = (int*)calloc(maxVal + 1, sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
    }
    
    // Find maximum frequency
    int maxFreq = 0;
    for (int i = 0; i <= maxVal; i++) {
        if (freq[i] > maxFreq) {
            maxFreq = freq[i];
        }
    }
    
    // Sum frequencies of elements with max frequency
    int result = 0;
    for (int i = 0; i <= maxVal; i++) {
        if (freq[i] == maxFreq) {
            result += freq[i];
        }
    }
    
    free(freq);
    return result;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &nums[size], &c)) {
        size++;
        if (c == ']') break;
    }
    
    printf("%d\n", maxFrequencyElements(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n unique elements, we scan the array of n elements to count occurrences

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing unique elements and their frequencies

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All elements are positive integers

89.4K Views

High Frequency

~15 min Avg. Time

1.8K 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 Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler