Count of subarrays of size K with average at least M - GeeksforGeeks

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 = 4Output: 4Explanation:Below are the subarrays of size K(= 3) whose average is at least M(= 4) as:
arr[3, 5]: The average is 4 which is at least M(= 4).arr[4, 6]: The average is 4.33 which is at least M(= 4).arr[5, 7]: The average is 5 which is at least M(= 4).arr[6, 8]: The average is 5.66 which is at least M(= 4).
arr[3, 5]: The average is 4 which is at least M(= 4).
arr[4, 6]: The average is 4.33 which is at least M(= 4).
arr[5, 7]: The average is 5 which is at least M(= 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 = 4Output: 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.
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++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <iostream>using namespace std; // Function to count the subarrays of// size K having average at least Mint 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 Codeint main(){    int arr[] = { 3, 6, 3, 2, 1, 3, 9 };    int K = 2, M = 4;    int N = sizeof(arr) / sizeof(arr[0]);     cout << countSubArrays(arr, N, K, M);     return 0;}
// Java program for the above approachimport 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.
# Python 3 code for the above approach # Function to count the subarrays of# size K having average at least Mdef 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 Codeif __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# 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
<script>       // JavaScript Program to implement       // the above approach        // Function to count the subarrays of       // size K having average at least M       function countSubArrays(arr, N,           K, M)       {           // Stores the resultant count of           // subarray           let count = 0;            // Stores the sum of subarrays of           // size K           let sum = 0;            // Add the values of first K elements           // to the sum           for (let 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 (let 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       let arr = [3, 6, 3, 2, 1, 3, 9];       let K = 2, M = 4;       let N = arr.length;        document.write(countSubArrays(arr, N, K, M));     // This code is contributed by Potta Lokesh    </script>
3
 
Time Complexity: O(N)Auxiliary Space: O(1) 
Kdheeraj
lokeshpotta20
ankthon
sliding-window
subarray
subarray-sum
two-pointer-algorithm
Arrays
Mathematical
sliding-window
two-pointer-algorithm
Arrays
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Program to find sum of elements in a given array
Trapping Rain Water
Reversal algorithm for array rotation
Move all negative numbers to beginning and positive to end with constant extra space
Window Sliding Technique
Program for Fibonacci numbers
Write a program to print all permutations of a given string
C++ Data Types
Set in C++ Standard Template Library (STL)
Program to find sum of elements in a given array