Apply Operations to Maximize Frequency Score

Apply Operations to Maximize Frequency Score - Problem

Array Binary Search Sliding Window Sorting Prefix Sum Hard

Imagine you're a data scientist with a powerful tool: you can modify any number in your dataset by increasing or decreasing it by 1, but you have a limited budget of k operations.

Given a 0-indexed integer array nums and an integer k, your goal is to strategically apply these operations to maximize the frequency of the most common element in the final array.

The Challenge:

You can perform at most k operations
Each operation allows you to +1 or -1 any element
Your score is the frequency (count) of the most frequent element
Return the maximum possible score

Example: With nums = [1,2,6,4] and k = 3, you could transform it to [1,2,2,2] using 3 operations: 6→4→3→2, giving you a frequency score of 3.

Input & Output

example_1.py — Basic Example

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

› Output: 3

💡 Note: We can transform the array to [2,2,2,4] by changing 1→2 (1 operation) and 6→4→3→2 (3 operations). This gives us 3 occurrences of the value 2, but we've used 4 operations total. Better: transform to [1,1,4,4] using 1 operation (2→1) and 2 operations (6→5→4), achieving frequency 2 with 3 operations. Actually optimal: [2,2,2,6] using 1+0+2=3 operations for frequency 3.

example_2.py — Small Budget

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

› Output: 2

💡 Note: We already have two 4's. With 1 operation, we could make 1→4 to get three 4's, but that costs 3 operations. We could make 1→2 or 1→3, but that doesn't help. We can achieve frequency 2 by doing nothing (the two 4's already exist) using 0 operations ≤ k=1.

example_3.py — Edge Case

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

› Output: 1

💡 Note: Single element array always has maximum frequency of 1, regardless of k value.

Visualization

Tap to expand

Understanding the Visualization

Arrange by Size

Sort the numbers like arranging clay pieces by height

Choose Group Size

Binary search to find the largest group size possible

Test Windows

For each group size, slide a window across sorted array

Calculate Cost

Find minimum cost to make each window identical

Key Takeaway

🎯 Key Insight: Sort first to group similar values, then use binary search + sliding window to efficiently find the largest achievable frequency within the operation budget.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting, O(log n) for binary search, O(n²) for sliding window validation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for sorted array and prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 2 × 10¹⁴
All values fit in standard integer types

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 24

The optimal approach uses sorting + sliding window with binary search on the answer. Sort the array first, then binary search on the possible frequency (1 to n). For each candidate frequency, use a sliding window to check all subarrays of that length and see if any can be made identical within k operations. The key insight is that in a sorted array, the optimal target for any window is often the median element, which minimizes the total cost.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer + Sliding Window	O(n² log n)	O(n)	Binary search on the answer (frequency) combined with sliding window to check feasibility
Brute Force (Try All Targets)	O(n² * R)	O(n)	Try every possible target value and calculate maximum achievable frequency

Binary Search on Answer + Sliding Window — Algorithm Steps

Sort the array to enable sliding window technique
Binary search on frequency from 1 to n
For each frequency f, use sliding window to check if any subarray of length f can be made identical within k operations
For each window, calculate cost using median as target (or try all values in window)
Return the maximum feasible frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort array to enable sliding window approach

Binary Search

Binary search on frequency from 1 to n

Sliding Window

For each frequency, check all windows of that size

Cost Calculation

Calculate minimum cost to make window elements identical

Code -

solution.c — C

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

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

int canAchieveFreq(int* nums, int n, int k, int freq) {
    if (freq == 1) return 1;
    
    for (int i = 0; i <= n - freq; i++) {
        int minCost = INT_MAX;
        for (int targetIdx = i; targetIdx < i + freq; targetIdx++) {
            int target = nums[targetIdx];
            int cost = 0;
            for (int j = i; j < i + freq; j++) {
                cost += abs(nums[j] - target);
            }
            if (cost < minCost) {
                minCost = cost;
            }
        }
        
        if (minCost <= k) return 1;
    }
    return 0;
}

int maxFrequencyScore(int* nums, int numsSize, int k) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    int left = 1, right = numsSize;
    int result = 1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieveFreq(nums, numsSize, k, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {1, 2, 6, 4};
    int k = 3;
    printf("%d\n", maxFrequencyScore(nums, 4, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

O(n log n) for sorting, O(log n) for binary search, O(n²) for sliding window validation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for sorted array and prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
0 ≤ k ≤ 2 × 10¹⁴
All values fit in standard integer types

62.1K Views

Medium-High Frequency

~35 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

Binary Search on Answer + Sliding Window — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler