Given a binary array **arr[]** of length **N**, the task is to find the minimum flips required in the array such that XOR of a consecutive sub-arrays of size K have different parity.

**Examples:**

Input:arr[] = {0, 1, 0, 1, 1}, K = 2

Output:2

Explanation:

For the above given array XOR of consective sub-array of size 2 is: {(0, 1): 1, (1, 0): 1, (0, 1): 1, (1, 1): 0}

There are two flips required which can be done on the following indices:

Index 0:It is required to flip the bit of the 0^{th}index, such that XOR of first sub-array remains 1.

Index 1:It is required to flip the bit of 1^{st}index, such that XOR of second sub-array becomes 0.

Input:arr[]={0, 0, 1, 1, 0, 0}, K = 3

Output:1

Explanation:

For the above given array XOR of consective sub-array of size 2 is: {(0, 0, 1): 1, (0, 1, 1): 0, (1, 1, 0): 0, (1, 0, 0): 1}

There is one flip required which can be done on the following indices:

Index 4:It is required to flip the bit of the 4^{th}index, such that XOR of third sub-array becomes 1 and XOR of fourth subarray becomes 0.

**Approach:** To make the different parity of consecutive subarrays, the total array is dependent upon the first subarray of size K. That is every next subarray of size K should be the negation of the previous subarray.

**For Example:** For an array of size 4, such that consecutive subarray of size 2 have different parity:

Let the first subarray of size 2 be {1, 1} Then the next subarray can be {0, 0} Consecutive subarrays of size 2 in this array: {(1, 1): 0, (1, 0): 1, (0, 0): 0}

Below is the implementation of the above approach:

## C++

`// C++ implementation to find the ` `// minimum flips required such that ` `// alternate subarrays have ` `// different parity ` ` ` `#include <iostream> ` `#include <limits.h> ` `using` `namespace` `std; ` ` ` ` ` `// Function to find the minimum ` `// flips required in binary array ` `int` `count_flips(` `int` `a[], ` `int` `n, ` `int` `k) ` `{ ` ` ` `// Boolean value to indicate ` ` ` `// odd or even value of 1's ` ` ` `bool` `set = ` `false` `; ` ` ` `int` `ans = 0, min_diff = INT_MAX; ` ` ` ` ` `// Loop to iterate over ` ` ` `// the subarrays of size K ` ` ` `for` `(` `int` `i = 0; i < k; i++) { ` ` ` ` ` `// curr_index is used to iterate ` ` ` `// over all the subarrays ` ` ` `int` `curr_index = i, segment = 0, ` ` ` `count_zero = 0, count_one = 0; ` ` ` ` ` `// Loop to iterate over the array ` ` ` `// at the jump of K to ` ` ` `// consider every parity ` ` ` `while` `(curr_index < n) { ` ` ` ` ` `// Condition to check if the ` ` ` `// subarray is at even position ` ` ` `if` `(segment % 2 == 0) { ` ` ` ` ` `// The value needs to be ` ` ` `// same as the first subarray ` ` ` `if` `(a[curr_index] == 1) ` ` ` `count_zero++; ` ` ` `else` ` ` `count_one++; ` ` ` `} ` ` ` `else` `{ ` ` ` `// The value needs to be ` ` ` `// opposite of the first subarray ` ` ` `if` `(a[curr_index] == 0) ` ` ` `count_zero++; ` ` ` `else` ` ` `count_one++; ` ` ` `} ` ` ` `curr_index = curr_index + k; ` ` ` `segment++; ` ` ` `} ` ` ` `ans += min(count_one, count_zero); ` ` ` `if` `(count_one < count_zero) ` ` ` `set = !set; ` ` ` `// Update the minimum difference ` ` ` `min_diff = min(min_diff, ` ` ` `abs` `(count_zero - count_one)); ` ` ` `} ` ` ` ` ` `// Condition to check if the 1s ` ` ` `// in the subarray is odd ` ` ` `if` `(set) ` ` ` `return` `ans; ` ` ` `else` ` ` `return` `ans + min_diff; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `n = 6, k = 3; ` ` ` `int` `a[] = { 0, 0, 1, 1, 0, 0 }; ` ` ` `cout << count_flips(a, n, k); ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java implementation to find the minimum flips ` `// required such that alternate subarrays ` `// have different parity ` ` ` `import` `java.util.*; ` ` ` `class` `Count_Flips { ` ` ` ` ` `// Function to find the minimum ` ` ` `// flips required in binary array ` ` ` `public` `static` `int` `count_flips( ` ` ` `int` `a[], ` `int` `n, ` `int` `k){ ` ` ` ` ` `// Boolean value to indicate ` ` ` `// odd or even value of 1's ` ` ` `boolean` `set = ` `false` `; ` ` ` `int` `ans = ` `0` `, ` ` ` `min_diff = Integer.MAX_VALUE; ` ` ` ` ` `// Loop to iterate over ` ` ` `// the subarrays of size K ` ` ` `for` `(` `int` `i = ` `0` `; i < k; i++) { ` ` ` ` ` `// curr_index is used to iterate ` ` ` `// over all the subarrays ` ` ` `int` `curr_index = i, segment = ` `0` `, ` ` ` `count_zero = ` `0` `, count_one = ` `0` `; ` ` ` ` ` `// Loop to iterate over the array ` ` ` `// at the jump of K to ` ` ` `// consider every parity ` ` ` `while` `(curr_index < n) { ` ` ` ` ` `// Condition to check if the ` ` ` `// subarray is at even position ` ` ` `if` `(segment % ` `2` `== ` `0` `) { ` ` ` ` ` `// The value needs to be ` ` ` `// same as the first subarray ` ` ` `if` `(a[curr_index] == ` `1` `) ` ` ` `count_zero++; ` ` ` `else` ` ` `count_one++; ` ` ` `} ` ` ` `else` `{ ` ` ` `// The value needs to be ` ` ` `// opposite of the first subarray ` ` ` `if` `(a[curr_index] == ` `0` `) ` ` ` `count_zero++; ` ` ` `else` ` ` `count_one++; ` ` ` `} ` ` ` `curr_index = curr_index + k; ` ` ` `segment++; ` ` ` `} ` ` ` `ans += Math.min(count_one, count_zero); ` ` ` `if` `(count_one < count_zero) ` ` ` `set = !set; ` ` ` `// Update the minimum difference ` ` ` `min_diff = Math.min(min_diff, ` ` ` `Math.abs(count_zero - count_one)); ` ` ` `} ` ` ` `// Condition to check if the 1s ` ` ` `// in the subarray is odd ` ` ` `if` `(set) ` ` ` `return` `ans; ` ` ` `else` ` ` `return` `ans + min_diff; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `n = ` `6` `, k = ` `3` `; ` ` ` `int` `a[] = { ` `0` `, ` `0` `, ` `1` `, ` `1` `, ` `0` `, ` `0` `}; ` ` ` `System.out.println(count_flips(a, n, k)); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python implementation to find the ` `# minimum flips required such that ` `# alternate subarrays have ` `# different parity ` ` ` `# Function to find the minimum ` `# flips required in binary array ` `def` `count_flips(a, n, k): ` ` ` `min_diff, ans, ` `set` `=` `n, ` `0` `, ` `False` ` ` ` ` `# Loop to iterate over ` ` ` `# the subarrays of size K ` ` ` `for` `i ` `in` `range` `(k): ` ` ` `# curr_index is used to iterate ` ` ` `# over all the subarrays ` ` ` `curr_index, segment,\ ` ` ` `count_zero, count_one ` `=` `\ ` ` ` `i, ` `0` `, ` `0` `, ` `0` ` ` ` ` `# Loop to iterate over the array ` ` ` `# at the jump of K to ` ` ` `# consider every parity ` ` ` `while` `curr_index < n: ` ` ` ` ` `# Condition to check if the ` ` ` `# subarray is at even position ` ` ` `if` `segment ` `%` `2` `=` `=` `0` `: ` ` ` `# The value needs to be ` ` ` `# same as the first subarray ` ` ` `if` `a[curr_index] ` `=` `=` `1` `: ` ` ` `count_zero ` `+` `=` `1` ` ` `else` `: ` ` ` `count_one ` `+` `=` `1` ` ` `else` `: ` ` ` `# The value needs to be ` ` ` `# opposite of the first subarray ` ` ` `if` `a[curr_index] ` `=` `=` `0` `: ` ` ` `count_zero ` `+` `=` `1` ` ` `else` `: ` ` ` `count_one ` `+` `=` `1` ` ` `curr_index ` `+` `=` `k ` ` ` `segment` `+` `=` `1` ` ` `ans ` `+` `=` `min` `(count_zero, count_one) ` ` ` `if` `count_one<count_zero: ` ` ` `set` `=` `not` `set` ` ` `min_diff ` `=` `min` `(min_diff,\ ` ` ` `abs` `(count_zero` `-` `count_one)) ` ` ` `# Condition to check if the 1s ` ` ` `# in the subarray is odd ` ` ` `if` `set` `: ` ` ` `return` `ans ` ` ` `else` `: ` ` ` `return` `ans ` `+` `min_diff ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` `n, k ` `=` `6` `, ` `3` ` ` `a ` `=` `[` `0` `, ` `0` `, ` `1` `, ` `1` `, ` `0` `, ` `0` `] ` ` ` `print` `(count_flips(a, n, k)) ` |

*chevron_right*

*filter_none*

## C#

`// C# implementation to find the minimum flips ` `// required such that alternate subarrays ` `// have different parity ` `using` `System; ` ` ` `class` `Count_Flips ` `{ ` ` ` ` ` `// Function to find the minimum ` ` ` `// flips required in binary array ` ` ` `static` `int` `count_flips(` `int` `[]a, ` `int` `n, ` `int` `k) ` ` ` `{ ` ` ` ` ` `// Boolean value to indicate ` ` ` `// odd or even value of 1's ` ` ` `bool` `set` `= ` `false` `; ` ` ` `int` `ans = 0, min_diff = ` `int` `.MaxValue; ` ` ` ` ` `// Loop to iterate over ` ` ` `// the subarrays of size K ` ` ` `for` `(` `int` `i = 0; i < k; i++) { ` ` ` ` ` `// curr_index is used to iterate ` ` ` `// over all the subarrays ` ` ` `int` `curr_index = i, segment = 0, ` ` ` `count_zero = 0, count_one = 0; ` ` ` ` ` `// Loop to iterate over the array ` ` ` `// at the jump of K to ` ` ` `// consider every parity ` ` ` `while` `(curr_index < n) { ` ` ` ` ` `// Condition to check if the ` ` ` `// subarray is at even position ` ` ` `if` `(segment % 2 == 0) { ` ` ` ` ` `// The value needs to be ` ` ` `// same as the first subarray ` ` ` `if` `(a[curr_index] == 1) ` ` ` `count_zero++; ` ` ` `else` ` ` `count_one++; ` ` ` `} ` ` ` `else` `{ ` ` ` `// The value needs to be ` ` ` `// opposite of the first subarray ` ` ` `if` `(a[curr_index] == 0) ` ` ` `count_zero++; ` ` ` `else` ` ` `count_one++; ` ` ` `} ` ` ` `curr_index = curr_index + k; ` ` ` `segment++; ` ` ` `} ` ` ` `ans += Math.Min(count_one, count_zero); ` ` ` `if` `(count_one < count_zero) ` ` ` `set` `= !` `set` `; ` ` ` ` ` `// Update the minimum difference ` ` ` `min_diff = Math.Min(min_diff, ` ` ` `Math.Abs(count_zero - count_one)); ` ` ` `} ` ` ` ` ` `// Condition to check if the 1s ` ` ` `// in the subarray is odd ` ` ` `if` `(` `set` `) ` ` ` `return` `ans; ` ` ` `else` ` ` `return` `ans + min_diff; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main(` `string` `[] args) ` ` ` `{ ` ` ` `int` `n = 6, k = 3; ` ` ` `int` `[]a = { 0, 0, 1, 1, 0, 0 }; ` ` ` `Console.WriteLine(count_flips(a, n, k)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Yash_R ` |

*chevron_right*

*filter_none*

**Output:**

1

**Performance Analysis:**

**Time Complexity:**As in the above approach, There is only one loop which takes O(N) time in worst case. Hence the Time Complexity will be**O(N)**.**Auxiliary Space Complexity:**As in the above approach, There is no extra space used. Hence the auxiliary space complexity will be**O(1)**.

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.

## Recommended Posts:

- Maximum subarray size, such that all subarrays of that size have sum less than k
- Minimum flips required in a binary string such that all K-size substring contains 1
- Minimum operations required to modify the array such that parity of adjacent elements is different
- Minimum flips in two binary arrays so that their XOR is equal to another array
- Minimum bit flips such that every K consecutive bits contain at least one set bit
- Minimum Group Flips to Make Binary Array Elements Same
- Minimum Subarray flips required to convert all elements of a Binary Array to K
- Compute the parity of a number using XOR and table look-up
- Query to count odd and even parity elements in subarray after XOR with K
- Minimum flips required to form given binary string where every flip changes all bits to its right as well
- Minimum Count of Bit flips required to make a Binary String Palindromic
- Minimum flips required to keep all 1s together in a Binary string
- Minimize the count of adjacent pairs with different parity
- Count of all subsequences having adjacent elements with different parity
- Create an array such that XOR of subarrays of length K is X
- Minimize swaps to rearrange array such that parity of index and corresponding element is same
- Construct a square Matrix whose parity of diagonal sum is same as size of matrix
- Count minimum right flips to set all values in an array
- Number of subarrays such that XOR of one half is equal to the other
- Minimum count of increment of K size subarrays required to form a given Array

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.