Maximum Frequency of an Element After Performing Operations I - Problem

Array Binary Search Sliding Window Sorting Prefix Sum Medium

You are given an integer array nums and two integers k and numOperations.

You must perform an operation numOperations times on nums, where in each operation you:

Select an index i that was not selected in any previous operations.
Add an integer in the range [-k, k] to nums[i].

Return the maximum possible frequency of any element in nums after performing the operations.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: We can change nums[0] to 2 (add 1) and nums[1] to 2 (subtract 2). However, we can only do 2 operations, so we can change nums[0] to 2 and keep nums[1] as 4. But better: change nums[0] from 1 to 4 (add 3, but this exceeds k). Actually, change nums[0] from 1 to 2 and nums[1] from 4 to 2, but nums[1] needs to change by 2 which exceeds k=1. Best solution: target value 4, change nums[0] from 1 to 4 (not possible with k=1). Target value 5: change nums[1] from 4 to 5 and keep nums[2] as 5, giving frequency 2.

Example 2 — All Same Target

$ Input: nums = [2,2,2], k = 2, numOperations = 2

› Output: 3

💡 Note: All elements are already the same value 2. We don't need any operations, but we can use up to 2 operations on different indices. Since all 3 elements can have the same value without any operations, the maximum frequency is 3.

Example 3 — Limited Operations

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

› Output: 4

💡 Note: All elements are already 1. Even though we can only perform 1 operation, all 4 elements already have the same value, so the maximum frequency is 4.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that the optimal target value must be reachable by at least one element in the array. We can try each element and its k-shifted values as potential targets, then count how many elements can reach each target within the operation limit. The optimized approach sorts the array first and intelligently selects target candidates. Time: O(n²), Space: O(1).

Common Approaches

✓ Stack

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

Binary Search on Answer

⏱️ Time: O(n² × k × log n) Space: O(n × k)

Since the answer is bounded between 1 and min(n, numOperations), we can binary search on the frequency value. For each candidate frequency, we check if it's possible to achieve by finding the best target value.

Brute Force - Try All Possible Targets

⏱️ Time: O(n² × k) Space: O(n × k)

For each possible target value, count how many elements can be transformed to that value within the operation limit. The possible targets are all values that any element can reach after adjustment.

Optimized with Sorting and Sliding Window

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

After sorting the array, we can use a sliding window approach to find the maximum number of elements that can be made equal. For each possible target value, we find the longest contiguous subsequence that can be adjusted to that target.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min_val(int a, int b) {
    return a < b ? a : b;
}

int max_val(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int numsSize, int k, int numOperations) {
    // Generate all possible target values
    int targets[100000];
    int targetCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int delta = -k; delta <= k; delta++) {
            int target = nums[i] + delta;
            // Check if target already exists
            int exists = 0;
            for (int j = 0; j < targetCount; j++) {
                if (targets[j] == target) {
                    exists = 1;
                    break;
                }
            }
            if (!exists) {
                targets[targetCount++] = target;
            }
        }
    }
    
    int maxFreq = 0;
    for (int i = 0; i < targetCount; i++) {
        int target = targets[i];
        int count = 0;
        
        // Count how many elements can reach this target
        for (int j = 0; j < numsSize; j++) {
            if (abs_val(nums[j] - target) <= k) {
                count++;
            }
        }
        
        // We can modify at most numOperations elements
        int achievable = min_val(count, numOperations);
        maxFreq = max_val(maxFreq, achievable);
    }
    
    return maxFreq;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[1000];
    int count = 0;
    char* ptr = line + 1;
    char* token = strtok(ptr, ",]");
    
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k, numOperations;
    scanf("%d", &k);
    scanf("%d", &numOperations);
    
    int result = solution(nums, count, k, numOperations);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

324 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