Maximum Average Subarray I - Practice Coding Problems

Maximum Average Subarray I - Problem

You are given an integer array nums consisting of n elements, and an integer k. Your task is to find a contiguous subarray whose length is exactly k that has the maximum average value.

Think of it like finding the best performing streak in a series of scores! For example, if you have test scores [1, 12, -5, -6, 50, 3] and want to find the best 4 consecutive scores, you'd calculate averages for each possible group of 4 and return the highest one.

Goal: Return the maximum average value as a floating-point number.

Note: Any answer within 10^-5 of the actual answer will be accepted.

Input & Output

example_1.py — Basic Case

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

› Output: 12.75000

💡 Note: Maximum average subarray is [12,-5,-6,50] with sum 51 and average 51/4 = 12.75

example_2.py — Single Element

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

› Output: 5.00000

💡 Note: Only one subarray possible: [5] with average 5.0

example_3.py — All Negative

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

› Output: -1.50000

💡 Note: Maximum average subarray is [-1,-2] with sum -3 and average -3/2 = -1.5

Constraints

n == nums.length
1 ≤ k ≤ n ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
k is always valid (k ≤ length of array)

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Calculate sum of first k elements to establish our baseline

Slide and Update

Move window right: subtract outgoing element, add incoming element

Track Maximum

Keep track of the highest sum encountered during sliding

Return Average

Divide the maximum sum by k to get the maximum average

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n*k) problem into O(n) by maintaining a running sum and updating it incrementally rather than recalculating from scratch.

Asked in

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

The optimal solution uses the sliding window technique to achieve O(n) time complexity. Instead of recalculating each window sum from scratch, we maintain a running sum and update it by removing the leftmost element and adding the new rightmost element as we slide the window. This reduces the time complexity from O(n*k) to O(n), making it highly efficient for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*k)	O(1)	Calculate sum for every possible subarray of length k
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to calculate maximum average in one pass

Brute Force (Nested Loops) — Algorithm Steps

Initialize maxSum to negative infinity
For each starting position i from 0 to n-k
Calculate sum of elements from i to i+k-1
Update maxSum if current sum is larger
Return maxSum divided by k

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Calculate sum of first k elements

Move to position 1

Recalculate sum from scratch for next k elements

Continue sliding

Repeat until all positions are checked

Code -

solution.c — C

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

double findMaxAverage(int* nums, int numsSize, int k) {
    double maxSum = INT_MIN;
    
    // Try each possible starting position
    for (int i = 0; i <= numsSize - k; i++) {
        int currentSum = 0;
        // Calculate sum for current window
        for (int j = i; j < i + k; j++) {
            currentSum += nums[j];
        }
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    return maxSum / k;
}

int main() {
    int nums[1000];
    int n = 0, k;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, ",");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",");
    }
    scanf("%d", &k);
    printf("%.5f\n", findMaxAverage(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We iterate through n-k+1 starting positions, and for each position, we sum k elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track maximum sum and current sum

✓ Linear Space

73.9K Views

High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler