Maximum Average Subarray II - Practice Coding Problems

Maximum Average Subarray II - 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 greater than or equal to k that has the maximum average value.

Unlike the simpler version where the subarray length is fixed, this problem allows variable-length subarrays (as long as they're at least k elements long). This makes it significantly more challenging because you need to consider all possible subarray lengths from k to n.

Example: Given nums = [1,12,-5,-6,50,3] and k = 4, you need to find the subarray of length ≥ 4 with the highest average. The subarray [12,-5,-6,50] has average 12.75, which turns out to be optimal.

Return the maximum average value as a double. 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: The subarray [12,-5,-6,50] has length 4 and average (12-5-6+50)/4 = 51/4 = 12.75, which is the maximum possible.

example_2.py — Minimum Length

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

› Output: 5.00000

💡 Note: Only one element, so the subarray is [5] with average 5.0.

example_3.py — All Negative

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

› Output: -1.50000

💡 Note: The best subarray is [-1,-2] with length 2 and average (-1-2)/2 = -1.5.

Constraints

n == nums.length
1 ≤ k ≤ n ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
Answer precision: Any answer within 10^-5 of the actual answer will be accepted

Visualization

Tap to expand

Understanding the Visualization

Set Search Bounds

Initialize left=min(nums) and right=max(nums) as possible average range

Binary Search Loop

For each mid value, check if there exists a valid subarray with average ≥ mid

Feasibility Check

Transform array by subtracting target, then find subarray with sum ≥ 0

Update Bounds

If feasible, search higher; otherwise search lower

Converge to Answer

Continue until bounds converge to maximum achievable average

Key Takeaway

🎯 Key Insight: By binary searching on the answer and using prefix sums for feasibility checks, we transform an O(n³) problem into an elegant O(n log(range)) solution.

Asked in

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

The optimal solution uses binary search on the answer with O(n log(max-min)) complexity. Instead of checking all subarrays, we binary search on possible average values and use prefix sums to efficiently verify if a target average is achievable with a subarray of length ≥ k.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n log(max-min))	O(1)	Binary search on the possible average values and check feasibility
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray of length ≥ k and calculate their averages

Binary Search on Answer — Algorithm Steps

Set binary search bounds: left = min(nums), right = max(nums)
While right - left > epsilon (10^-5):
Calculate mid = (left + right) / 2
Check if there exists a subarray of length >= k with average >= mid
If yes, update left = mid; otherwise, update right = mid
Return left as the maximum achievable average

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Bounds

Set left=min(nums), right=max(nums) as search bounds

Binary Search

For each mid value, check if achievable using prefix sums

Converge

Narrow bounds until we find the maximum achievable average

Code -

solution.c — C

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

bool canAchieveAverage(int* nums, int numsSize, int k, double target) {
    double prefixSum = 0;
    double minPrefix = 0;
    
    // Check first k elements
    for (int i = 0; i < k; i++) {
        prefixSum += nums[i] - target;
    }
    
    if (prefixSum >= 0) return true;
    
    // Use sliding window technique
    for (int i = k; i < numsSize; i++) {
        prefixSum += nums[i] - target;
        minPrefix += nums[i - k] - target;
        
        if (minPrefix > 0) {
            minPrefix = 0;
        }
        
        if (prefixSum - minPrefix >= 0) {
            return true;
        }
    }
    
    return false;
}

double findMaxAverage(int* nums, int numsSize, int k) {
    double left = nums[0], right = nums[0];
    
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] < left) left = nums[i];
        if (nums[i] > right) right = nums[i];
    }
    
    while (right - left > 1e-5) {
        double mid = (left + right) / 2;
        if (canAchieveAverage(nums, numsSize, k, mid)) {
            left = mid;
        } else {
            right = mid;
        }
    }
    
    return left;
}

int main() {
    printf("Implement input parsing\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max-min))

Binary search iterations * O(n) feasibility check per iteration

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

34.5K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler