K Radius Subarray Averages

K Radius Subarray Averages - Problem

You are given a 0-indexed array nums of n integers, and an integer k.

The k-radius average for a subarray of nums centered at some index i with the radius k is the average of all elements in nums between the indices i - k and i + k (inclusive). If there are less than k elements before or after the index i, then the k-radius average is -1.

Build and return an array avgs of length n where avgs[i] is the k-radius average for the subarray centered at index i.

The average of x elements is the sum of the x elements divided by x, using integer division. The integer division truncates toward zero, which means losing its fractional part.

For example, the average of four elements 2, 3, 1, and 5 is (2 + 3 + 1 + 5) / 4 = 11 / 4 = 2.75, which truncates to 2.

Input & Output

Example 1 — Basic Case

$ Input: nums = [7,4,3,9,1,8,5,2,6], k = 3

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

💡 Note: Only index 3 has 3 elements on both sides. Window is [7,4,3,9,1,8,5] with sum 37, so average is 37/7 = 5.

Example 2 — Smaller Radius

$ Input: nums = [1,12,-5,-6,50,3], k = 1

› Output: [-1,2,0,13,15,-1]

💡 Note: For k=1, window size is 3. Index 1: (1+12-5)/3 = 8/3 = 2. Index 2: (12-5-6)/3 = 1/3 = 0. Index 3: (-5-6+50)/3 = 39/3 = 13. Index 4: (-6+50+3)/3 = 47/3 = 15.

Example 3 — All Invalid

$ Input: nums = [8], k = 100000

› Output: [-1]

💡 Note: k=100000 is larger than array length, so no valid windows exist.

Constraints

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

Visualization

Tap to expand

Asked in

f Meta 25 a Amazon 18 G Google 12

The sliding window approach is optimal, maintaining a running sum as we move the window across the array. First k and last k positions are always -1 since they don't have enough neighbors. For valid positions, we slide the window by removing the leftmost element and adding the new rightmost element. Time: O(n), Space: O(1).

Common Approaches

✓ Dp 2d

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

Memoization

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

Brute Force

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

For each position i, check if we have k elements on both sides. If yes, sum all elements from i-k to i+k and divide by 2k+1. If not enough elements, return -1.

Sliding Window

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

Calculate the first valid window sum, then slide the window by removing the leftmost element and adding the new rightmost element. This avoids recalculating overlapping sums.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

double max(double a, double b) {
    return a > b ? a : b;
}

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

double solution(int* nums, int n, int k) {
    // dp[i][j] = max score for nums[0:i] using at most j partitions
    double dp[101][101];
    
    // Initialize with negative infinity
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= k; j++) {
            dp[i][j] = -1e9;
        }
    }
    
    // Base case: empty array needs 0 partitions
    dp[0][0] = 0;
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= min(i, k); j++) {
            // Try all possible positions for the last partition
            int currentSum = 0;
            for (int prev = i - 1; prev >= 0; prev--) {
                currentSum += nums[prev];
                double avg = (double) currentSum / (i - prev);
                if (dp[prev][j - 1] != -1e9) {
                    dp[i][j] = max(dp[i][j], dp[prev][j - 1] + avg);
                }
            }
        }
    }
    
    double result = -1e9;
    for (int j = 1; j <= k; j++) {
        result = max(result, dp[n][j]);
    }
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int n = 0;
    
    // Parse JSON array format [1,2,3,4]
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++; // Skip '['
        char* end_ptr = strchr(ptr, ']');
        if (end_ptr) {
            *end_ptr = '\0'; // Null terminate before ']'
        }
        
        char* token = strtok(ptr, ",");
        while (token != NULL && n < 100) {
            nums[n++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    int k;
    scanf("%d", &k);
    
    double result = solution(nums, n, k);
    printf("%f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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