Frequency of the Most Frequent Element - Problem

Array Binary Search Greedy Sliding Window Sorting Prefix Sum Medium

The frequency of an element is the number of times it occurs in an array.

You are given an integer array nums and an integer k. In one operation, you can choose an index of nums and increment the element at that index by 1.

Return the maximum possible frequency of an element after performing at most k operations.

Input & Output

Example 1 — Basic Case

$ Input: nums = [1,2,4], k = 5

› Output: 3

💡 Note: We can make all elements equal to 4 by incrementing 1 by 3 and 2 by 2, using 5 operations total. Final array: [4,4,4] with frequency 3.

Example 2 — Limited Operations

$ Input: nums = [1,4,8,13], k = 5

› Output: 2

💡 Note: We can make [1,4] both equal to 4 using 3 operations (1→4 needs 3 ops). Or make [4,8] both equal to 8 using 4 operations. Maximum frequency is 2.

Example 3 — Single Element

$ Input: nums = [3], k = 0

› Output: 1

💡 Note: With only one element and no operations allowed, the maximum frequency is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 🍎 Apple 25

The key insight is to sort the array first and use a sliding window approach. We always target the rightmost element in the current window as our goal value. The optimal approach uses sliding window with prefix sums for O(n log n) time and O(1) space.

Common Approaches

✓ One Pass Hash

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

Brute Force - Try All Targets

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

For each possible target value (max element in array), try all subarrays and calculate how many operations are needed to make all elements equal to the target.

Optimized Sliding Window with Prefix Sum

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

Sort the array first, then use a sliding window approach with prefix sums to efficiently calculate the operations needed. The key insight is that we always target the rightmost element in the window.

Sort + Sliding Window

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

Sort the array to group similar values together. Use sliding window technique to find the longest subarray that can be made equal with at most k operations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int nums[100000];
static int costs[100000];
static int candidates[100000];

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int numsSize, int k) {
    int maxFreq = 1;
    
    // Get unique values as candidates
    int candidatesSize = 0;
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        for (int j = 0; j < candidatesSize; j++) {
            if (candidates[j] == nums[i]) {
                found = 1;
                break;
            }
        }
        if (!found) {
            candidates[candidatesSize++] = nums[i];
        }
    }
    
    for (int i = 0; i < candidatesSize; i++) {
        int target = candidates[i];
        
        // For this target, find how many elements we can make equal to target
        int costsSize = 0;
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] <= target) {
                costs[costsSize++] = target - nums[j];
            }
        }
        
        // Sort costs and take as many as possible within k operations
        qsort(costs, costsSize, sizeof(int), compare);
        int operations = 0;
        int freq = 0;
        
        for (int j = 0; j < costsSize; j++) {
            if (operations + costs[j] <= k) {
                operations += costs[j];
                freq++;
            } else {
                break;
            }
        }
        
        if (freq > maxFreq) {
            maxFreq = freq;
        }
    }
    
    return maxFreq;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int numsSize = 0;
    char *ptr = line + 1; // Skip '['
    char *token;
    
    // Handle empty array
    if (line[1] == ']') {
        numsSize = 0;
    } else {
        while ((token = strtok(ptr, ",]")) != NULL) {
            nums[numsSize++] = atoi(token);
            ptr = NULL;
        }
    }
    
    // Read k
    int k;
    scanf("%d", &k);
    
    // Call solution and print result
    int result = solution(numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

89.0K Views

High Frequency

~25 min Avg. Time

2.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