K Radius Subarray Averages - Practice Coding Problems

K Radius Subarray Averages - Problem

You're given an array of integers and need to calculate the k-radius average for each position in the array.

The k-radius average at index i is the average of all elements within a radius of k positions from i. This includes elements from index i-k to i+k (inclusive).

Important rules:

If there aren't enough elements on either side (less than k elements before or after index i), return -1 for that position
Use integer division that truncates toward zero
The window size is always 2*k + 1 elements when valid

Example: For array [7,4,3,9,1,8,5,2,6] with k=3, at index 4 (value 1), we average elements from index 1 to 7: (4+3+9+1+8+5+2)/7 = 32/7 = 4

Input & Output

example_1.py — Basic Case

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

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

💡 Note: For k=3, we need 7 elements (2*3+1) in each window. Only indices 3,4,5 have valid windows. Index 3: avg([7,4,3,9,1,8,5]) = 37/7 = 5. Index 4: avg([4,3,9,1,8,5,2]) = 32/7 = 4. Index 5: avg([3,9,1,8,5,2,6]) = 34/7 = 4.

example_2.py — Small K

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

› Output: [100000]

💡 Note: When k=0, the window size is 1, so each element is its own average. The only element 100000 has average 100000/1 = 100000.

example_3.py — K Too Large

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

› Output: [-1]

💡 Note: k=100000 requires a window of size 200001, but we only have 1 element. No valid windows exist, so return [-1].

Visualization

Tap to expand

Understanding the Visualization

Setup Sensors

Place temperature sensors along a highway with readings at each position

Initial Window

Calculate average for first valid k-radius window around a station

Slide Window

Move to next station: drop leftmost reading, add new rightmost reading

Update Average

Compute new average using updated sum, avoiding recalculation

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n×k) problem into O(n) by reusing overlapping calculations instead of starting from scratch each time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each element added and removed exactly once

✓ Linear Growth

Space Complexity

O(1)

Only storing window sum and a few variables besides output array

✓ Linear Space

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
0 ≤ nums[i], k ≤ 10⁵
Important: Use integer division that truncates toward zero

Asked in

A Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses the sliding window technique to achieve O(n) time complexity. Instead of recalculating the sum for each window, we maintain a running sum and slide the window by removing the leftmost element and adding the new rightmost element. This reduces redundant calculations from O(n×k) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to maintain running sum and avoid recalculation
Brute Force (Nested Loops)	O(n*k)	O(1)	For each position, calculate the sum of all elements in the k-radius window

Sliding Window (Optimal) — Algorithm Steps

Initialize result array with -1 for all positions
Calculate window size = 2*k + 1
If window size > array length, return all -1s
Calculate sum for the first valid window (centered at index k)
Set result[k] = windowSum / windowSize
Slide window: remove left element, add new right element
Update result for each subsequent valid position

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize First Window

Calculate sum for window centered at index k

Slide Window Right

Remove leftmost element, add new rightmost element

Continue Sliding

Update running sum incrementally for each position

Code -

solution.c — C

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

int* getAverages(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    // Initialize all positions to -1
    for (int i = 0; i < numsSize; i++) {
        result[i] = -1;
    }
    
    int windowSize = 2 * k + 1;
    
    // If window is larger than array, all positions are invalid
    if (windowSize > numsSize) {
        return result;
    }
    
    // Calculate sum for first valid window
    long long windowSum = 0;
    for (int i = 0; i < windowSize; i++) {
        windowSum += nums[i];
    }
    
    // Set result for first valid position
    result[k] = windowSum / windowSize;
    
    // Slide the window
    for (int i = k + 1; i < numsSize - k; i++) {
        // Remove leftmost element of previous window
        windowSum -= nums[i - k - 1];
        // Add rightmost element of current window
        windowSum += nums[i + k];
        
        result[i] = windowSum / windowSize;
    }
    
    return result;
}

int main() {
    int nums[] = {7, 4, 3, 9, 1, 8, 5, 2, 6};
    int numsSize = 9;
    int k = 3;
    int returnSize;
    
    int* result = getAverages(nums, numsSize, k, &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)

Single pass through array, each element added and removed exactly once

✓ Linear Growth

Space Complexity

O(1)

Only storing window sum and a few variables besides output array

✓ Linear Space

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
0 ≤ nums[i], k ≤ 10⁵
Important: Use integer division that truncates toward zero

43.2K Views

Medium-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

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler