Maximum Beauty of an Array After Applying Operation

Maximum Beauty of an Array After Applying Operation - Problem

You are given a 0-indexed array nums and a non-negative integer k.

In one operation, you can do the following:

Choose an index i that hasn't been chosen before from the range [0, nums.length - 1].
Replace nums[i] with any integer from the range [nums[i] - k, nums[i] + k].

The beauty of the array is the length of the longest subsequence consisting of equal elements.

Return the maximum possible beauty of the array nums after applying the operation any number of times.

Note: You can apply the operation to each index only once. A subsequence of an array is a new array generated from the original array by deleting some elements (possibly none) without changing the order of the remaining elements.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: We can transform the array to [4,4,3,4]. Elements at indices 0, 2, and 3 become equal (ignoring order), so beauty = 3.

Example 2 — Large k Value

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

› Output: 4

💡 Note: All elements are already equal, so we can make all 4 elements the same value. Beauty = 4.

Example 3 — No Overlap Possible

$ Input: nums = [1,10], k = 2

› Output: 1

💡 Note: Element 1 can become [1-2,1+2] = [-1,3]. Element 10 can become [10-2,10+2] = [8,12]. No overlap possible, so beauty = 1.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that after each element can be transformed to a range [nums[i]-k, nums[i]+k], we need to find the maximum number of ranges that can overlap at some common target value. The optimal approach uses sliding window on sorted array - sort first, then use two pointers to find the maximum window where nums[right] - nums[left] ≤ 2k. Time: O(n log n), Space: O(1)

Common Approaches

✓ Optimized

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

Binary Search on Answer

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

Use binary search to find the maximum possible beauty. For each candidate beauty value, check if it's possible to select that many elements that can all be transformed to the same target value.

Brute Force - Try All Target Values

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

For each possible target value, count how many elements in the array can be transformed to reach that target within their allowed range [nums[i] - k, nums[i] + k].

Sliding Window on Sorted Array

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

Sort the array first, then use a sliding window to find the maximum number of elements whose ranges [nums[i]-k, nums[i]+k] can overlap at a common target value.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

int solution(int* nums, int n, int k) {
    if (n <= 1) return n;
    
    // Sort the array
    qsort(nums, n, sizeof(int), compare);
    
    int maxBeauty = 1;
    int left = 0;
    
    // Use sliding window to find maximum overlapping ranges
    for (int right = 0; right < n; right++) {
        // While the current window is invalid (no overlap possible)
        // For overlap: nums[right] - nums[left] <= 2k
        while (nums[right] - nums[left] > 2 * k) {
            left++;
        }
        int currentSize = right - left + 1;
        if (currentSize > maxBeauty) {
            maxBeauty = currentSize;
        }
    }
    
    return maxBeauty;
}

int main() {
    static int nums[100005];
    char line[1000000];
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char *ptr = line;
    
    // Skip '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
        if (*ptr && *ptr != ']') {
            nums[n++] = (int)strtol(ptr, &ptr, 10);
        }
    }
    
    // Read k
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, n, k));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear 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