Maximum Equal Frequency - Practice Coding Problems

Maximum Equal Frequency - Problem

Maximum Equal Frequency is a challenging problem that tests your understanding of frequency analysis and edge case handling.

Given an array nums of positive integers, you need to find the longest possible prefix where removing exactly one element results in all remaining numbers having the same frequency.

Key Points:
• A prefix is a subarray starting from index 0
• You must remove exactly one element from the prefix
• After removal, all unique numbers must have equal occurrences
• If no elements remain after removal, it's considered valid (all have frequency 0)

Example: In array [2,2,1,1,5,3,3,5], the prefix [2,2,1,1,5] of length 5 works because removing one occurrence of any number (say 5) leaves us with frequencies: 2 appears twice, 1 appears twice - all equal!

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: For prefix [2,2,1,1,5,3,3] of length 7, we have frequencies: 2 appears 2 times, 1 appears 2 times, 3 appears 2 times, 5 appears 1 time. Removing the single occurrence of 5 leaves all numbers with frequency 2.

example_2.py — All Same Frequency

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

› Output: 5

💡 Note: For prefix [1,1,2,2,3] of length 5, frequencies are: 1 appears 2 times, 2 appears 2 times, 3 appears 1 time. Removing one occurrence of 3 leaves frequencies [2,2], or removing one occurrence of 1 or 2 gives frequencies [1,2,1] which isn't equal. But removing the single 3 works.

example_3.py — Edge Case

$ Input: [1]

› Output: 1

💡 Note: Array with single element. Removing it results in empty array where all elements (none) have equal frequency 0.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
The array contains only positive integers

Visualization

Tap to expand

Understanding the Visualization

Track Frequencies

Maintain count of how many times each number appears

Track Frequency Distribution

Count how many numbers have each frequency value

Check Valid Patterns

Recognize if current state matches any of the 5 valid patterns

Update Maximum

Keep track of the longest valid prefix found

Key Takeaway

🎯 Key Insight: Instead of trying all possible removals, recognize the 5 mathematical patterns where removing exactly one element creates equal frequencies. This reduces time complexity from O(n³) to O(n).

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 18

The optimal solution uses frequency tracking with pattern recognition in O(n) time. We maintain two hash maps: one tracking element frequencies and another tracking frequency counts. The key insight is recognizing that only 5 specific patterns allow removing one element to achieve equal frequencies: all frequencies equal 1, only one unique number, one number appears once while others have equal frequency, frequencies differ by 1 with higher appearing once, or all have same frequency with specific balance conditions.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Track frequencies and frequency counts, recognizing valid patterns as we build the array
Brute Force (Check All Prefixes)	O(n³)	O(n)	For each prefix, try removing each element and check if remaining frequencies are equal

One-Pass Hash Table (Optimal) — Algorithm Steps

Maintain frequency map of elements and count map of frequencies
For each element, update both maps and track maximum frequency
Check if current state matches any of the 5 valid patterns
Update result if a valid pattern is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Frequencies

Maintain frequency map and frequency count map

Pattern Check

Check if current state matches any valid pattern

Update Result

Update maximum length if pattern is valid

Continue

Process next element

Code -

solution.c — C

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

#define MAX_VAL 100001

int maxEqualFreq(int* nums, int numsSize) {
    int freq[MAX_VAL] = {0};     // frequency of each number
    int count[numsSize + 1];     // count of each frequency
    memset(count, 0, sizeof(count));
    
    int maxFreq = 0;
    int result = 0;
    int uniqueNums = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        
        // Update frequency maps
        if (freq[num] > 0) {
            count[freq[num]]--;
        } else {
            uniqueNums++;
        }
        
        freq[num]++;
        count[freq[num]]++;
        if (freq[num] > maxFreq) {
            maxFreq = freq[num];
        }
        
        int length = i + 1;
        
        // Count how many different frequencies we have
        int freqTypes = 0;
        int freq1 = -1, freq2 = -1;
        int count1 = 0, count2 = 0;
        
        for (int f = 1; f <= maxFreq; f++) {
            if (count[f] > 0) {
                freqTypes++;
                if (freq1 == -1) {
                    freq1 = f;
                    count1 = count[f];
                } else if (freq2 == -1) {
                    freq2 = f;
                    count2 = count[f];
                }
            }
        }
        
        // Check valid patterns
        if (maxFreq == 1) {
            result = length;
        } else if (uniqueNums == 1) {
            result = length;
        } else if (freqTypes == 2) {
            if ((freq1 == 1 && count1 == 1) || (freq2 == 1 && count2 == 1) ||
                (freq1 == freq2 + 1 && count1 == 1) || (freq2 == freq1 + 1 && count2 == 1) ||
                (freq1 == maxFreq && count1 == 1 && freq2 * count2 == length - maxFreq) ||
                (freq2 == maxFreq && count2 == 1 && freq1 * count1 == length - maxFreq)) {
                result = length;
            }
        } else if (freqTypes == 1) {
            if (freq1 == 1 || uniqueNums == 1 || freq1 * uniqueNums == length - 1) {
                result = length;
            }
        }
    }
    
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    char* token = strtok(input, "[,]");
    while (token != NULL && n < 1000) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", maxEqualFreq(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) operations per element

✓ Linear Growth

Space Complexity

O(n)

Space for frequency maps, bounded by number of unique elements

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 min Avg. Time

856 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler