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. Your goal is to maximize the beauty of the array through strategic operations.

What can you do? For each index i in the array (you can use each index only once), you can replace nums[i] with any integer in the range [nums[i] - k, nums[i] + k].

What is beauty? The beauty of an array is the length of the longest subsequence consisting of equal elements. Remember, a subsequence maintains the original order but can skip elements.

Your mission: Return the maximum possible beauty after applying the operation optimally.

Example: If nums = [4,6,1,2] and k = 2, you could transform it to [4,4,3,4] by choosing appropriate values within each element's allowed range, giving a beauty of 3 (three 4's).

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: We can transform the array to [4,4,3,4] by choosing values within each element's range: nums[0]=4 stays 4, nums[1]=6 becomes 4 (within [4,8]), nums[2]=1 becomes 3 (within [-1,3]), nums[3]=2 becomes 4 (within [0,4]). The longest subsequence of equal elements is [4,4,4] with length 3.

example_2.py — All Same Target

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

› Output: 4

💡 Note: All elements are already the same, so we can keep them all as 1. The beauty is 4.

example_3.py — No Overlap

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

› Output: 1

💡 Note: The ranges are [−1,3], [8,12], and [18,22]. No two ranges overlap, so we can't make any two elements equal. Maximum beauty is 1.

Visualization

Tap to expand

Understanding the Visualization

Line Up Musicians

Sort musicians by their natural pitch (sort the array)

Find Harmony Groups

Musicians close in pitch can more easily play the same note

Sliding Window

Use a window to find the largest group where range ≤ 2k

Maximum Harmony

The largest valid group gives us the maximum beauty

Key Takeaway

🎯 Key Insight: After sorting, elements that can be made equal form contiguous groups where the range is at most 2k. Use sliding window to find the largest such group efficiently!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then O(n) binary searches each taking O(log n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for indices and results

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i], k ≤ 10⁵
Each index can only be used once
A subsequence maintains the original order

Asked in

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

The optimal solution uses sliding window technique after sorting the array. Key insight: elements that can be made equal will form a contiguous group in the sorted array where the difference between max and min is at most 2k. Sort the array in O(n log n), then use two pointers to find the maximum window size where this condition holds, achieving overall O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search Solution	O(n log n)	O(1)	Sort array and use binary search to find valid ranges efficiently
Sliding Window (Optimal)	O(n log n)	O(1)	Sort array and use sliding window to find the largest valid group
Brute Force (Try All Target Values)	O(n * range)	O(1)	Try every possible target value and count how many elements can reach it

Binary Search Solution — Algorithm Steps

Sort the array in ascending order
For each index i as the left boundary
Binary search for the rightmost index j where nums[j] - nums[i] ≤ 2k
The group size starting at i is j - i + 1
Track the maximum group size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort the array: [1, 2, 4, 6]

For Each Start

Use each index as potential group start

Binary Search

Find rightmost valid element in group

Calculate Size

Group size = right - left + 1

Code -

solution.c — C

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

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

int binarySearchRight(int* nums, int numsSize, int leftIdx, int target) {
    int left = leftIdx;
    int right = numsSize - 1;
    int result = leftIdx;
    
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] - nums[leftIdx] <= target) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int maximumBeauty(int* nums, int numsSize, int k) {
    if (numsSize == 0) return 0;
    
    qsort(nums, numsSize, sizeof(int), compare);
    int maxBeauty = 1;
    
    for (int i = 0; i < numsSize; i++) {
        // Find rightmost position where difference ≤ 2k
        int rightIdx = binarySearchRight(nums, numsSize, i, 2 * k);
        int currentSize = rightIdx - i + 1;
        if (currentSize > maxBeauty) {
            maxBeauty = currentSize;
        }
    }
    
    return maxBeauty;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then O(n) binary searches each taking O(log n)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for indices and results

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i], k ≤ 10⁵
Each index can only be used once
A subsequence maintains the original order

42.3K Views

High Frequency

~18 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 Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler