Frequency of the Most Frequent Element - Practice Coding Problems

Frequency of the Most Frequent Element - Problem

Array Binary Search Greedy Sliding Window Sorting Prefix Sum Medium

Imagine you have an array of numbers and a limited budget of operations to make elements more frequent. The frequency of an element is simply how many times it appears in the array.

You're given an integer array nums and an integer k representing your operation budget. In each operation, you can increment any element by 1. Your goal is to maximize the frequency of any single element after performing at most k operations.

Key insight: You can only increase elements (never decrease), so the optimal strategy involves picking a target value and incrementing smaller elements to match it.

Example: Given [1,2,4] and k=5, you could turn this into [4,4,4] using 5 operations: increment first element 3 times (1→4) and second element 2 times (2→4), achieving a frequency of 3.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: We can increment 1 to 4 (3 operations) and 2 to 4 (2 operations) using exactly 5 operations. All three elements become 4, giving us a frequency of 3.

example_2.py — Limited Operations

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

› Output: 2

💡 Note: We can make 2 elements equal. For example, increment 1 to 4 (3 operations) or increment 4 to 8 (4 operations). With k=5, we can achieve frequency 2 but not 3.

example_3.py — No Operations Needed

$ Input: nums = [3,9,6], k = 2

› Output: 1

💡 Note: With only 2 operations, we cannot make any two elements equal. The minimum difference is |6-3|=3, which exceeds k=2. Maximum frequency remains 1.

Visualization

Tap to expand

Understanding the Visualization

Sort Players by Score

Arrange players from lowest to highest score to identify efficient groupings

Use Sliding Window

Consider consecutive players as potential groups, expanding when budget allows

Calculate Boost Cost

For each group, calculate total boost points needed to equalize scores

Find Optimal Group Size

Track the largest group you can create within your boost point budget

Key Takeaway

🎯 Key Insight: Sort the array first, then use a sliding window where the window size represents how many elements can be made equal to the rightmost element within k operations. The cost formula efficiently calculates required operations without nested loops.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements as target, we potentially scan all n elements to calculate cost

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁹
Important: You can only increment elements, never decrement

Asked in

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

The optimal approach uses a sliding window technique after sorting the array. The key insight is that we should always target an existing element value, and sorting allows us to efficiently calculate the cost of making consecutive elements equal using the formula: cost = window_size × target - sum_of_window. This achieves O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Targets)	O(n²)	O(1)	Try each element as a target and calculate the minimum operations needed
Sliding Window (Two Pointers)	O(n log n)	O(1)	Sort array and use sliding window to find optimal subarray

Brute Force (Try All Targets) — Algorithm Steps

For each element as a potential target value
Sort elements to prioritize smaller values (cheaper to increment)
Greedily increment elements towards the target until k operations are exhausted
Track the maximum frequency achieved

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Target

Select an element as the target value

Calculate Costs

Find the cost to increment each element to the target

Sort and Greedily Apply

Apply operations starting with cheapest increments

Track Maximum

Keep track of the best frequency achieved

Code -

solution.c — C

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

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

int findMaxFrequency(int* nums, int numsSize, int k) {
    int maxFreq = 1;
    
    // Try each element as a potential target
    for (int i = 0; i < numsSize; i++) {
        int target = nums[i];
        int* costs = (int*)malloc(numsSize * sizeof(int));
        int costCount = 0;
        
        // Calculate cost to make elements equal to target
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] <= target) {
                costs[costCount++] = target - nums[j];
            }
        }
        
        // Sort costs to prioritize cheaper increments
        qsort(costs, costCount, sizeof(int), compare);
        
        long long operations = 0;
        int freq = 0;
        
        // Greedily use operations on cheapest increments
        for (int j = 0; j < costCount; j++) {
            if (operations + costs[j] <= k) {
                operations += costs[j];
                freq++;
            } else {
                break;
            }
        }
        
        if (freq > maxFreq) {
            maxFreq = freq;
        }
        
        free(costs);
    }
    
    return maxFreq;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    printf("%d\n", findMaxFrequency(nums, n, k));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements as target, we potentially scan all n elements to calculate cost

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10⁹
Important: You can only increment elements, never decrement

34.3K Views

High Frequency

~18 min Avg. Time

1.5K 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 (Try All Targets) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler