Count Elements With Maximum Frequency

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

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

✓ Dp 2d

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n²) Space: O(1)

For each unique element, count its frequency by scanning the entire array. Then find the maximum frequency and sum up frequencies of all elements that have this maximum frequency.

Single-Pass Optimized

⏱️ Time: O(n) Space: O(n)

Build frequency map and track maximum frequency simultaneously in one pass. Keep running count of how many elements have maximum frequency and update result as we discover new maximums.

Two-Pass Hash Map

⏱️ Time: O(n) Space: O(n)

Use a hash map to count frequencies of all elements in first pass. Then iterate through the frequency map to find maximum frequency and sum up frequencies of elements that have this maximum.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int n) {
    if (n < 4) return 0;
    
    // Allocate 2D arrays
    int** left = (int**)malloc(n * sizeof(int*));
    int** right = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        left[i] = (int*)calloc(n, sizeof(int));
        right[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Precompute left[j][k]
    for (int j = 0; j < n; j++) {
        for (int k = 0; k < n; k++) {
            for (int i = 0; i < j; i++) {
                if (nums[i] < nums[k]) {
                    left[j][k]++;
                }
            }
        }
    }
    
    // Precompute right[j][k]
    for (int j = 0; j < n; j++) {
        for (int k = 0; k < n; k++) {
            for (int l = k + 1; l < n; l++) {
                if (nums[j] < nums[l]) {
                    right[j][k]++;
                }
            }
        }
    }
    
    int count = 0;
    for (int j = 1; j < n - 2; j++) {
        for (int k = j + 1; k < n - 1; k++) {
            // Must have nums[k] < nums[j] for valid pattern
            if (nums[k] < nums[j]) {
                count += left[j][k] * right[j][k];
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(left[i]);
        free(right[i]);
    }
    free(left);
    free(right);
    
    return count;
}

int main() {
    char line[100000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array [1,2,3,4,...]
    int nums[10000];
    int n = 0;
    
    char* p = line;
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p) p++; // Skip '['
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\t')) p++;
        
        if (*p == ']') break;
        
        // Parse number
        if (isdigit(*p) || *p == '-') {
            char* endptr;
            long val = strtol(p, &endptr, 10);
            nums[n++] = (int)val;
            p = endptr;
        } else {
            p++;
        }
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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