Related Articles

# 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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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