# Minimum flips to make mean of all k size sub-arrays less than 1

• Last Updated : 03 Mar, 2022

Given an array A of size N, having each element either 0 or 1 and an integer K. Find the minimum number of elements that need to be flipped, such that no sub-array of size greater than or equal to K has an arithmetic mean of 1.

Examples:

Input: N = 5, A = {1, 1, 1, 1, 1}, K = 5
Output: 1
Explanation: Initially, mean of only sub-array of size 5 is (1+1+1+1+1)/5 = 1. So,  flip the first element (i.e. make it 0).  The array now becomes {0, 1, 1, 1, 1}, whose mean is less than 1. So, we needed just 1 flip to satisfy the required condition.
Note that {1, 1, 1, 1, 0} also satisfies required condition. Other arrays are also possible.

Input: N = 4, A = {1, 1, 0, 1}, K = 2
Output: 1
Explanation: flip the first 1 (i.e. element at 0 index), to that resultant array becomes {0, 1, 0, 1} in which no sub-array of size 2 of more has a mean 1.
Note that {1, 0, 0, 1} is also a possible array satisfying required condition.

Approach: This problem can be easily solved by using the Greedy technique.
The observation is that a binary array of size K has an arithmetic mean equal to 1 only if all the K elements in it are equal to 1. Also, if all of the sub-arrays of size K have meant less than 1, then all sub-arrays of size greater than K  would also have meant less than 1. So, the following approach can be used to solve the problem-

• Start traversing the given array.
• maintain the current count of consecutive ones till the current index in a variable, say “count”.
• If the current element is 1, we increment the count by 1, else we make it 0, as the consecutive 1s ending on ith index becomes 0.
• If the count becomes equal to K, that means there are K consecutive 1s ending on the current index, so we increment the answer by 1 (that implies the current index would be made 0 )and again make the count variable 0.

Below is the implementation of the above approach:

## C++

 `// C++ program to find Minimum flips to``// Make mean of all k size``// Sub-arrays less than 1` `#include ``using` `namespace` `std;` `// Function to calculate``// Minimum flips to  make``// Mean of all k size``// Subarrays less than 1``int` `minimumFlips(``int` `N, ``int` `A[], ``int` `K)``{``    ``// Initializing answer by 0``    ``// That stores the number of flips``    ``int` `answer = 0;` `    ``// Initializing count variable by 0``    ``// That stores the number of consecutive 1s``    ``int` `count = 0;` `    ``// iterating through the array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(A[i] == 1) {``            ``// If current element is 1,``            ``// We increment count by 1``            ``count++;` `            ``// if count of consecutive 1s``            ``// Reaches k, we increment the answer``            ``// as the mean of the subarray from``            ``// i-k to ith element becomes 1``            ``if` `(count == K) {``                ``answer++;``                ``count = 0;``            ``}``        ``}` `        ``// else if current element is``        ``// 0, we make count 0``        ``else` `{``            ``count = 0;``        ``}``    ``}` `    ``// returning the required answer``    ``return` `answer;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5, K = 5;``    ``int` `A[] = { 1, 1, 1, 1, 1 };``    ``int` `minimum_flips = minimumFlips(N, A, K);``    ``cout << minimum_flips;``}`

## Java

 `// Java program to find Minimum flips to``// Make mean of all k size``// Sub-arrays less than 1``import` `java.io.*;` `class` `GFG {` `  ``// Function to calculate``  ``// Minimum flips to  make``  ``// Mean of all k size``  ``// Subarrays less than 1``  ``static` `int` `minimumFlips(``int` `N, ``int` `A[], ``int` `K)``  ``{``    ` `    ``// Initializing answer by 0``    ``// That stores the number of flips``    ``int` `answer = ``0``;` `    ``// Initializing count variable by 0``    ``// That stores the number of consecutive 1s``    ``int` `count = ``0``;` `    ``// iterating through the array``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``      ``if` `(A[i] == ``1``)``      ``{``        ` `        ``// If current element is 1,``        ``// We increment count by 1``        ``count++;` `        ``// if count of consecutive 1s``        ``// Reaches k, we increment the answer``        ``// as the mean of the subarray from``        ``// i-k to ith element becomes 1``        ``if` `(count == K) {``          ``answer++;``          ``count = ``0``;``        ``}``      ``}` `      ``// else if current element is``      ``// 0, we make count 0``      ``else` `{``        ``count = ``0``;``      ``}``    ``}` `    ``// returning the required answer``    ``return` `answer;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args) {``    ``int` `N = ``5``, K = ``5``;``    ``int` `A[] = { ``1``, ``1``, ``1``, ``1``, ``1` `};``    ``int` `minimum_flips = minimumFlips(N, A, K);``    ``System.out.println( minimum_flips);``  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python

 `# Python program to find Minimum flips to``# Make mean of all k size``# Sub-arrays less than 1` `# Function to calculate``# Minimum flips to  make``# Mean of all k size``# Subarrays less than 1``def` `minimumFlips(N, A, K):``    ` `    ``# Initializing answer by 0``    ``# That stores the number of flips``    ``answer ``=` `0` `    ``# Initializing count variable by 0``    ``# That stores the number of consecutive 1s``    ``count ``=` `0` `    ``# iterating through the array``    ``for` `i ``in` `range``(``0``, N):``        ``if` `(A[i] ``=``=` `1``):``            ` `            ``# If current element is 1,``            ``# We increment count by 1``            ``count ``+``=` `1` `            ``# if count of consecutive 1s``            ``# Reaches k, we increment the answer``            ``# as the mean of the subarray from``            ``# i-k to ith element becomes 1``            ``if` `(count ``=``=` `K):``                ``answer ``+``=` `1``                ``count ``=` `0` `        ``# else if current element is``        ``# 0, we make count 0``        ``else``:``            ``count ``=` `0` `    ``# returning the required answer``    ``return` `answer` `# Driver Code``N ``=` `5``K ``=` `5``A ``=` `[ ``1``, ``1``, ``1``, ``1``, ``1` `]``minimum_flips ``=` `minimumFlips(N, A, K)``print``(minimum_flips)` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# program to find Minimum flips to``// Make mean of all k size``// Sub-arrays less than 1``using` `System;` `class` `GFG {` `  ``// Function to calculate``  ``// Minimum flips to  make``  ``// Mean of all k size``  ``// Subarrays less than 1``  ``static` `int` `minimumFlips(``int` `N, ``int``[] A, ``int` `K)``  ``{` `    ``// Initializing answer by 0``    ``// That stores the number of flips``    ``int` `answer = 0;` `    ``// Initializing count variable by 0``    ``// That stores the number of consecutive 1s``    ``int` `count = 0;` `    ``// iterating through the array``    ``for` `(``int` `i = 0; i < N; i++) {``      ``if` `(A[i] == 1) {` `        ``// If current element is 1,``        ``// We increment count by 1``        ``count++;` `        ``// if count of consecutive 1s``        ``// Reaches k, we increment the answer``        ``// as the mean of the subarray from``        ``// i-k to ith element becomes 1``        ``if` `(count == K) {``          ``answer++;``          ``count = 0;``        ``}``      ``}` `      ``// else if current element is``      ``// 0, we make count 0``      ``else` `{``        ``count = 0;``      ``}``    ``}` `    ``// returning the required answer``    ``return` `answer;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `N = 5, K = 5;``    ``int``[] A = { 1, 1, 1, 1, 1 };``    ``int` `minimum_flips = minimumFlips(N, A, K);``    ``Console.WriteLine(minimum_flips);``  ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

Output

`1`

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

My Personal Notes arrow_drop_up