Sliding Subarray Beauty

Sliding Subarray Beauty - Problem

Given an integer array nums containing n integers, find the beauty of each subarray of size k.

The beauty of a subarray is the xth smallest integer in the subarray if it is negative, or 0 if there are fewer than x negative integers.

Return an integer array containing n - k + 1 integers, which denote the beauty of the subarrays in order from the first index in the array.

A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

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

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

Example 2 — Insufficient Negatives

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

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

💡 Note: Each window of size 2 has at most 2 elements, so fewer than 3 negatives. Beauty is 0 for all windows.

Example 3 — 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 beauty is always 0.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 35 M Microsoft 28 G Google 22 Apple 15

The key insight is that only negative numbers contribute to subarray beauty, and they're bounded (-50 to 50). The optimal approach uses a sliding window with fixed-size frequency array for O(1) updates and O(50) queries per window. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

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

For each possible subarray of size k, extract all negative numbers, sort them, and return the x-th smallest if it exists, otherwise 0.

Fixed Array Frequency Counter

⏱️ Time: O(n × 50) Space: O(50)

Since negative values are bounded (typically -50 to -1), use a fixed-size array instead of hash map for O(1) frequency updates and O(50) linear search for x-th smallest.

Sliding Window with Frequency Map

⏱️ Time: O(n × 50) Space: O(50)

Use a sliding window technique with a frequency map to track negative numbers. As the window slides, update counts and find the x-th smallest efficiently.

Brute Force — Algorithm Steps

Iterate through all subarrays of size k
For each subarray, collect negative numbers
Sort negatives and pick x-th element if available

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Window

Get k consecutive elements

Filter & Sort

Keep only negatives and sort them

Pick x-th

Return x-th smallest or 0

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 numsSize, int k, int x, int* returnSize) {
    *returnSize = numsSize - k + 1;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    
    for (int i = 0; i <= numsSize - k; i++) {
        int negatives[1000];
        int negCount = 0;
        
        for (int j = i; j < i + k; j++) {
            if (nums[j] < 0) {
                negatives[negCount++] = nums[j];
            }
        }
        
        qsort(negatives, negCount, sizeof(int), compare);
        if (negCount >= x) {
            result[i] = negatives[x - 1];
        } else {
            result[i] = 0;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    // Parse array from line like "[1,-1,-3,-2,3]"
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endptr;
        int num = (int)strtol(p, &endptr, 10);
        if (p != endptr) {
            nums[numsSize++] = num;
            p = endptr;
        } else {
            break;
        }
    }
    
    int k, x;
    scanf("%d", &k);
    scanf("%d", &x);
    
    int returnSize;
    int* result = solution(nums, numsSize, k, x, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k × log k)

n-k+1 subarrays, each processes k elements and sorts up to k negatives

⚡ Linearithmic

Space Complexity

O(k)

Array to store negative numbers from each subarray

✓ Linear Space

28.4K Views

Medium Frequency

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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler