Sliding Subarray Beauty - Practice Coding Problems

Sliding Subarray Beauty - Problem

You're given an integer array nums containing n integers and two parameters k and x. Your task is to find the "beauty" of each sliding window of size k as you move through the array.

The beauty of a subarray is defined as:

The xth smallest negative integer in the subarray, OR
0 if there are fewer than x negative integers

Note: Only negative numbers contribute to the beauty calculation - positive numbers and zeros are ignored for ranking purposes.

Return an array of n - k + 1 integers representing the beauty values of all possible subarrays of size k.

Example: For array [1, -1, -3, -2, 3] with k=3, x=2, the first window [1, -1, -3] has negatives [-3, -1], so the 2nd smallest is -1.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,-1,-3,-2,3], k = 3, x = 2

› Output: [-1,-2,-2]

💡 Note: Window [1,-1,-3]: negatives are [-3,-1], 2nd smallest is -1. Window [-1,-3,-2]: negatives are [-3,-2,-1], 2nd smallest is -2. Window [-3,-2,3]: negatives are [-3,-2], 2nd smallest is -2.

example_2.py — Insufficient Negatives

$ Input: nums = [-1,-2,-3,1,2,3], k = 2, x = 3

› Output: [0,0,0,0,0]

💡 Note: Each window of size 2 has at most 2 negative numbers, but we need the 3rd smallest, so all results are 0.

example_3.py — All Positives

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

› Output: [0,0,0]

💡 Note: No negative numbers in any window, so all beauty values are 0.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ k ≤ n
1 ≤ x ≤ k
-50 ≤ nums[i] ≤ 50

Visualization

Tap to expand

Understanding the Visualization

Set Window Size

Define inspection batch size k and target rank x

Track Defects

Use frequency counter for defective items in current batch

Calculate Beauty

Find x-th worst defect level, or 0 if insufficient defects

Slide Batch

Move to next batch, updating defect counters efficiently

Key Takeaway

🎯 Key Insight: By constraining negatives to [-50, -1], we can use a fixed-size frequency array and achieve O(n) sliding window processing instead of repeatedly sorting each window.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 f Meta 8

The optimal solution uses a sliding window with frequency counting. Since negative values are constrained to [-50, -1], we can use a fixed-size frequency array to track negatives in the current window. As we slide the window, we efficiently update frequencies and find the x-th smallest negative in O(1) amortized time, achieving overall O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Frequency Map (Optimal)	O(n)	O(1)	Maintain a frequency map of negatives in current window and track x-th smallest efficiently
Brute Force (Sort Each Window)	O(n * k * log(k))	O(k)	For each window, collect negatives, sort them, and find the x-th smallest

Sliding Window with Frequency Map (Optimal) — Algorithm Steps

Initialize frequency array for negatives [-50, -1]
Process first window and populate frequency map
Find x-th smallest negative in current window
Slide window: remove leftmost element, add rightmost element
Update frequencies and find new x-th smallest
Repeat until all windows are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Set up frequency array for first k elements

Find x-th Smallest

Scan frequency array to find x-th negative

Slide Window

Remove left element, add right element

Update Frequencies

Adjust frequency counts for changed elements

Code -

solution.c — C

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

int findXthSmallest(int* freq, int x) {
    int count = 0;
    for (int i = 0; i < 50; i++) {
        count += freq[i];
        if (count >= x) {
            return -(50 - i);
        }
    }
    return 0;
}

int* slidingSubarrayBeauty(int* nums, int numsSize, int k, int x, int* returnSize) {
    *returnSize = numsSize - k + 1;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    int freq[50] = {0};
    
    // Initialize first window
    for (int i = 0; i < k; i++) {
        if (nums[i] < 0) {
            freq[50 + nums[i]]++;
        }
    }
    
    result[0] = findXthSmallest(freq, x);
    
    // Slide window
    for (int i = k; i < numsSize; i++) {
        if (nums[i - k] < 0) {
            freq[50 + nums[i - k]]--;
        }
        if (nums[i] < 0) {
            freq[50 + nums[i]]++;
        }
        result[i - k + 1] = findXthSmallest(freq, x);
    }
    
    return result;
}

int main() {
    int nums[] = {1, -1, -3, -2, 3};
    int returnSize;
    int* result = slidingSubarrayBeauty(nums, 5, 3, 2, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with O(50) = O(1) operations per window to find x-th smallest

✓ Linear Growth

Space Complexity

O(1)

Fixed-size frequency array of 50 elements for negatives [-50, -1]

✓ Linear Space

28.5K Views

Medium-High Frequency

~18 min Avg. Time

847 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

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Frequency Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler