Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold

Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold - Problem

You're given an array of integers arr and two important parameters: k (the subarray size) and threshold (the minimum average). Your task is to find how many contiguous subarrays of exactly size k have an average that meets or exceeds the threshold.

Think of it as a quality control problem: you're scanning through data windows of fixed size and counting how many meet your quality standards. For example, if you have test scores [2, 2, 2, 2, 5, 5, 5, 8] and want to find 3-student groups with an average of at least 4, you'd slide a window of size 3 across the array and check each group's average.

Key insight: Instead of calculating averages (which involves division), you can multiply the threshold by k and compare against the sum directly. This avoids floating-point precision issues!

Input & Output

basic_case.py — Python

$ Input: arr = [2,2,2,2,5,5,5,8], k = 3, threshold = 4

› Output: 3

💡 Note: Sub-arrays [2,5,5], [5,5,5] and [5,5,8] have averages 4, 5 and 6 respectively. All other sub-arrays of size 3 have averages less than 4.

no_valid_subarrays.py — Python

$ Input: arr = [11,13,17,23,29,31,7,5,2,3], k = 3, threshold = 5

› Output: 6

💡 Note: The first 6 sub-arrays of size 3 have averages greater than 5. Note that averages are not integers.

edge_case_exact_size.py — Python

$ Input: arr = [1,1,1], k = 3, threshold = 1

› Output: 1

💡 Note: The only sub-array of size 3 is [1,1,1] with average 1, which equals the threshold.

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Calculate sum of first k elements: [2,2,2] = 6

Slide Right

Remove 2, add 2: sum becomes 6-2+2 = 6

Continue Sliding

Remove 2, add 5: sum becomes 6-2+5 = 9

Check Threshold

Compare sum ≥ threshold×k to count valid subarrays

Key Takeaway

🎯 Key Insight: The sliding window technique eliminates redundant calculations by maintaining a running sum as we slide through the array, achieving optimal O(n) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

For each of (n-k+1) starting positions, we sum k elements

✓ Linear Growth

Space Complexity

O(1)

Only using variables to store current sum and counter

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁴
1 ≤ k ≤ arr.length
0 ≤ threshold ≤ 10⁴
All array elements are positive integers

Asked in

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

The optimal solution uses the sliding window technique to achieve O(n) time complexity. Instead of recalculating sums for each subarray, we maintain a running sum by removing the leftmost element and adding the rightmost element as we slide the window. The key insight is to compare threshold × k with the sum directly, avoiding floating-point division.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*k)	O(1)	Check every possible subarray of size k by recalculating sum each time
Sliding Window (Optimal)	O(n)	O(1)	Calculate first window sum, then slide by removing left element and adding right element

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each possible starting position (0 to n-k)
For each position, sum the next k elements
Calculate average and compare with threshold
Increment counter if average >= threshold

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Calculate sum of first k elements

Move to index 1

Recalculate sum of next k elements

Continue sliding

Repeat until end of array

Code -

solution.c — C

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

int numOfSubarrays(int* arr, int arrSize, int k, int threshold) {
    int count = 0;
    int targetSum = threshold * k;
    
    // Check each possible starting position
    for (int i = 0; i <= arrSize - k; i++) {
        int currentSum = 0;
        // Calculate sum of k elements starting at position i
        for (int j = i; j < i + k; j++) {
            currentSum += arr[j];
        }
        
        // Check if average meets threshold
        if (currentSum >= targetSum) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int arr[100000];
    int arrSize = 0;
    int k, threshold;
    
    // Read array
    char c;
    while (scanf("%d%c", &arr[arrSize], &c)) {
        arrSize++;
        if (c == '\n') break;
    }
    
    scanf("%d %d", &k, &threshold);
    
    printf("%d\n", numOfSubarrays(arr, arrSize, k, threshold));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

For each of (n-k+1) starting positions, we sum k elements

✓ Linear Growth

Space Complexity

O(1)

Only using variables to store current sum and counter

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁴
1 ≤ k ≤ arr.length
0 ≤ threshold ≤ 10⁴
All array elements are positive integers

42.3K Views

High Frequency

~15 min Avg. Time

1.5K 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler