 Open in App
Not now

# Count of subarrays of size K with average at least M

• Difficulty Level : Easy
• Last Updated : 14 Sep, 2021

Given an array arr[] consisting of N integers and two positive integers K and M, the task is to find the number of subarrays of size K whose average is at least M.

Examples:

Input: arr[] = {2, 3, 3, 4, 4, 4, 5, 6, 6}, K = 3, M = 4
Output: 4
Explanation:
Below are the subarrays of size K(= 3) whose average is at least M(= 4) as:

1. arr[3, 5]: The average is 4 which is at least M(= 4).
2. arr[4, 6]: The average is 4.33 which is at least M(= 4).
3. arr[5, 7]: The average is 5 which is at least M(= 4).
4. arr[6, 8]: The average is 5.66 which is at least M(= 4).

Therefore, the count of the subarray is given by 4.

Input: arr[] = {3, 6, 3, 2, 1, 3, 9] K = 2, M = 4
Output: 3

Approach: The given problem can be solved by using the Two Pointers and Sliding Window Technique. Follow the steps below to solve the given problem:

• Initialize a variable, say count as 0 that stores the count of all possible subarrays.
• Initialize a variable, say sum as 0 that stores the sum of elements of the subarray of size K.
• Find the sum of the first K array elements and store it in the variable sum. If the value of sum is at least M*K, then increment the value of count by 1.
• Traverse the given array arr[] over the range [K, N – 1] using the variable i and perform the following steps:
• Add the value of arr[i] to the variable sum and subtract the value of arr[i – K] from the sum.
• If the value of sum is at least M*K, then increment the value of count by 1.
• After completing the above steps, print the value of count as the resultant count of subarrays.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count the subarrays of``// size K having average at least M``int` `countSubArrays(``int` `arr[], ``int` `N,``                   ``int` `K, ``int` `M)``{``    ``// Stores the resultant count of``    ``// subarray``    ``int` `count = 0;` `    ``// Stores the sum of subarrays of``    ``// size K``    ``int` `sum = 0;` `    ``// Add the values of first K elements``    ``// to the sum``    ``for` `(``int` `i = 0; i < K; i++) {``        ``sum += arr[i];``    ``}` `    ``// Increment the count if the``    ``// current subarray is valid``    ``if` `(sum >= K * M)``        ``count++;` `    ``// Traverse the given array``    ``for` `(``int` `i = K; i < N; i++) {` `        ``// Find the updated sum``        ``sum += (arr[i] - arr[i - K]);` `        ``// Check if current subarray``        ``// is valid or not``        ``if` `(sum >= K * M)``            ``count++;``    ``}` `    ``// Return the count of subarrays``    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 3, 6, 3, 2, 1, 3, 9 };``    ``int` `K = 2, M = 4;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << countSubArrays(arr, N, K, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``3``, ``6``, ``3``, ``2``, ``1``, ``3``, ``9` `};``        ``int` `K = ``2``, M = ``4``;``        ``System.out.println(countSubArrays(arr, K, M));``    ``}``  ` `    ``// Function to count the subarrays of``    ``// size K having average at least M``    ``public` `static` `int` `countSubArrays(``int``[] arr, ``int` `K,``                                     ``int` `M)``    ``{``      ` `        ``// Stores the resultant count of``        ``// subarray``        ``int` `count = ``0``;` `        ``// Stores the sum of subarrays of``        ``// size K``        ``int` `sum = ``0``;` `        ``// Add the values of first K elements``        ``// to the sum``        ``for` `(``int` `i = ``0``; i < K; i++) {``            ``sum += arr[i];``        ``}` `        ``// Increment the count if the``        ``// current subarray is valid``        ``if` `(sum >= K * M)``            ``count++;` `        ``// Traverse the given array``        ``for` `(``int` `i = K; i < arr.length; i++) {` `            ``// Find the updated sum``            ``sum += (arr[i] - arr[i - K]);` `            ``// Check if current subarray``            ``// is valid or not``            ``if` `(sum >= K * M)``                ``count++;``        ``}` `        ``// Return the count of subarrays``        ``return` `count;``    ``}``}` `// This code is contributed by Kdheeraj.`

## Python3

 `# Python 3 code for the above approach` `# Function to count the subarrays of``# size K having average at least M``def` `countSubArrays(arr, N, K, M):``  ` `    ``# Stores the resultant count of``    ``# subarray``    ``count ``=` `0` `    ``# Stores the sum of subarrays of``    ``# size K``    ``sum` `=` `0` `    ``# Add the values of first K elements``    ``# to the sum``    ``for` `i ``in` `range``(K):``        ``sum` `+``=` `arr[i]` `    ``# Increment the count if the``    ``# current subarray is valid``    ``if` `sum` `>``=` `K``*``M:``        ``count ``+``=` `1` `    ``# Traverse the given array``    ``for` `i ``in` `range``(K, N):` `        ``# Find the updated sum``        ``sum` `+``=` `(arr[i] ``-` `arr[i ``-` `K])` `        ``# Check if current subarray``        ``# is valid or not``        ``if` `sum` `>``=` `K``*``M:``            ``count ``+``=` `1` `    ``# Return the count of subarrays``    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``3``, ``6``, ``3``, ``2``, ``1``, ``3``, ``9``]``    ``K ``=` `2``    ``M ``=` `4``    ``N ``=` `len``(arr)``    ``count ``=` `countSubArrays(arr, N, K, M)``    ``print``(count)` `    ``# This code is contributed by Kdheeraj.`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG``{``  ` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { 3, 6, 3, 2, 1, 3, 9 };``        ``int` `K = 2, M = 4;``        ``Console.WriteLine(countSubArrays(arr, K, M));``    ``}``  ` `    ``// Function to count the subarrays of``    ``// size K having average at least M``    ``public` `static` `int` `countSubArrays(``int``[] arr, ``int` `K,``                                     ``int` `M)``    ``{``      ` `        ``// Stores the resultant count of``        ``// subarray``        ``int` `count = 0;` `        ``// Stores the sum of subarrays of``        ``// size K``        ``int` `sum = 0;` `        ``// Add the values of first K elements``        ``// to the sum``        ``for` `(``int` `i = 0; i < K; i++) {``            ``sum += arr[i];``        ``}` `        ``// Increment the count if the``        ``// current subarray is valid``        ``if` `(sum >= K * M)``            ``count++;` `        ``// Traverse the given array``        ``for` `(``int` `i = K; i < arr.Length; i++) {` `            ``// Find the updated sum``            ``sum += (arr[i] - arr[i - K]);` `            ``// Check if current subarray``            ``// is valid or not``            ``if` `(sum >= K * M)``                ``count++;``        ``}` `        ``// Return the count of subarrays``        ``return` `count;``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output:

`3`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up