Maximum Average Subarray II

Maximum Average Subarray II - Problem

You are given an integer array nums consisting of n elements, and an integer k.

Find a contiguous subarray whose length is greater than or equal to k that has the maximum average value and return this value.

Any answer with a calculation error less than 10^-5 will be accepted.

Input & Output

Example 1 — 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 length 4, giving average 51/4 = 12.75

Example 2 — Minimum Length

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

› Output: 5.00000

💡 Note: Only one element, so the subarray [5] has average 5.0

Example 3 — All Negative

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

› Output: -1.50000

💡 Note: Best subarray is [-1,-2] with average (-1-2)/2 = -1.5

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 A Amazon 22

The key insight is to use binary search on the answer space rather than searching for subarrays directly. The optimal approach uses binary search on possible average values combined with a sliding window feasibility check. Time: O(n log(max-min)), Space: O(n)

Common Approaches

✓ Greedy

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

Binary Search on Answer

⏱️ Time: O(n log(max-min)) Space: O(n)

Instead of finding the subarray directly, we binary search on the answer. For each candidate average, we check if there exists a subarray of length ≥ k with at least that average using a sliding window technique.

Brute Force

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

Generate all contiguous subarrays with length at least k, calculate their averages, and return the maximum. This involves nested loops to try every starting position and every valid ending position.

Prefix Sum Optimization

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

Build a prefix sum array to quickly calculate any subarray sum. This reduces the time to calculate each subarray average from O(n) to O(1), improving overall complexity.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int solution(int* piles, int pilesSize) {
    qsort(piles, pilesSize, sizeof(int), compare);
    int n = pilesSize / 3;
    int result = 0;
    
    // Take the middle n elements (from index n to 2n-1)
    for (int i = n; i < 2 * n; i++) {
        result += piles[i];
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int piles[1000];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        while (*token == ' ') token++; // skip spaces
        if (strlen(token) > 0) {
            piles[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", solution(piles, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.0K Views

Medium Frequency

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