# Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal

Given two binary arrays X[] and Y[] of size N, the task is to convert array X[] into array Y[] by minimum number of operations of selecting any subarray of odd length and flipping all odd-indexed elements from the subarray.

Examples:

Input: X[] = {1, 0, 0, 0, 0, 1}, Y[] = {1, 1, 0, 1, 1, 1}
Output: 2
Explanation:
Initially, X[] is {1, 0, 0, 0, 0, 1}.
Operation 1: Choose the sub-array {0, 0, 0} from array X[] and change the 2nd and 4th character and convert it to {1, 0, 1}.
Now X becomes {1, 1, 0, 1, 0, 1}.
Operation 2: Choose the sub-array {0} containing only the 5th character and convert it to 1.
Finally, X becomes {1, 1, 0, 1, 1, 1}, which is equal to Y.
Therefore, the count of operations is 2.

Input: X[] = {0, 1, 0}, Y[] = {0, 1, 0}
Output: 0
Explanation:
Since both the arrays X and Y are equal thus the minimum operations would be 0.

Approach: The idea is to count the operations for both even and odd positions individually. Follow the steps below to solve the problem:

• Initialize a variable C as 0 to store the count of operations.
• Traverse the array X[] elements over odd positions and take a counter count = 0.
• Check for consecutive unequal elements between X[i] and Y[i] and increase the counter count by 1 every time.
• When X[i] and Y[i] are equal increase a global C to increase operation by 1 since in that one operation all odd positions can be made equal to as in Y.
• Similarly, Traverse the array X[] elements over even positions and again take a counter count = 0.
• Check for consecutive unequal elements between X[i] and Y[i] and increase the counter count by 1 every time.
• When X[i] and Y[i] are equal increase a global counter C to increase operation by 1.
• After the above steps, print the value of C as the resultant count of operations required.

Below is the implementation of the above approach:

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the minimum flip` `// of subarrays required at alternate` `// index to make binary arrays equals` `void` `minOperation(``int` `X[], ``int` `Y[],` `                  ``int` `n)` `{` `    ``// Stores count of total operations` `    ``int` `C = 0;`   `    ``// Stores count of consecutive` `    ``// unequal elements` `    ``int` `count = 0;`   `    ``// Loop to run on odd positions` `    ``for` `(``int` `i = 1; i < n; i = i + 2) {`   `        ``if` `(X[i] != Y[i]) {` `            ``count++;` `        ``}` `        ``else` `{`   `            ``// Incrementing the` `            ``// global counter` `            ``if` `(count != 0)` `                ``C++;`   `            ``// Change count to 0` `            ``count = 0;` `        ``}` `    ``}`   `    ``// If all last elements are equal` `    ``if` `(count != 0)` `        ``C++;`   `    ``count = 0;`   `    ``// Loop to run on even positions` `    ``for` `(``int` `i = 0; i < n; i = i + 2) {`   `        ``if` `(X[i] != Y[i]) {` `            ``count++;` `        ``}` `        ``else` `{`   `            ``// Incrementing the` `            ``// global counter` `            ``if` `(count != 0)` `                ``C++;`   `            ``// Change count to 0` `            ``count = 0;` `        ``}` `    ``}`   `    ``if` `(count != 0)` `        ``C++;`   `    ``// Print the minimum operations` `    ``cout << C;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `X[] = { 1, 0, 0, 0, 0, 1 };` `    ``int` `Y[] = { 1, 1, 0, 1, 1, 1 };` `    ``int` `N = ``sizeof``(X) / ``sizeof``(X);`   `    ``// Function Call` `    ``minOperation(X, Y, N);`   `    ``return` `0;` `}`

 `// Java program for the above approach ` `import` `java.util.*;` `   `  `class` `GFG{` `   `  `// Function to find the minimum flip` `// of subarrays required at alternate` `// index to make binary arrays equals` `static` `void` `minOperation(``int` `X[], ``int` `Y[],` `                         ``int` `n)` `{` `    `  `    ``// Stores count of total operations` `    ``int` `C = ``0``;` ` `  `    ``// Stores count of consecutive` `    ``// unequal elements` `    ``int` `count = ``0``;` ` `  `    ``// Loop to run on odd positions` `    ``for``(``int` `i = ``1``; i < n; i = i + ``2``)` `    ``{` `        `  `        ``if` `(X[i] != Y[i]) ` `        ``{` `            ``count++;` `        ``}` `        ``else` `        ``{` `            `  `            ``// Incrementing the` `            ``// global counter` `            ``if` `(count != ``0``)` `                ``C++;` ` `  `            ``// Change count to 0` `            ``count = ``0``;` `        ``}` `    ``}` ` `  `    ``// If all last elements are equal` `    ``if` `(count != ``0``)` `        ``C++;` ` `  `    ``count = ``0``;` ` `  `    ``// Loop to run on even positions` `    ``for``(``int` `i = ``0``; i < n; i = i + ``2``) ` `    ``{` `        ``if` `(X[i] != Y[i]) ` `        ``{` `            ``count++;` `        ``}` `        ``else` `        ``{` `            `  `            ``// Incrementing the` `            ``// global counter` `            ``if` `(count != ``0``)` `                ``C++;` ` `  `            ``// Change count to 0` `            ``count = ``0``;` `        ``}` `    ``}` ` `  `    ``if` `(count != ``0``)` `        ``C++;` ` `  `    ``// Print the minimum operations` `    ``System.out.print(C);` `}` `   `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `X[] = { ``1``, ``0``, ``0``, ``0``, ``0``, ``1` `};` `    ``int` `Y[] = { ``1``, ``1``, ``0``, ``1``, ``1``, ``1` `};` `    ``int` `N = X.length;` ` `  `    ``// Function Call` `    ``minOperation(X, Y, N);` `}` `}`   `// This code is contributed by susmitakundugoaldanga`

 `# Python program for the above approach`   `# Function to find the minimum flip` `# of subarrays required at alternate` `# index to make binary arrays equals` `def` `minOperation(X, Y, n):` `  `  `    ``# Stores count of total operations` `    ``C ``=` `0``;`   `    ``# Stores count of consecutive` `    ``# unequal elements` `    ``count ``=` `0``;`   `    ``# Loop to run on odd positions` `    ``for` `i ``in` `range``(``1``, n, ``2``):`   `        ``if` `(X[i] !``=` `Y[i]):` `            ``count ``+``=` `1``;` `        ``else``:`   `            ``# Incrementing the` `            ``# global counter` `            ``if` `(count !``=` `0``):` `                ``C ``+``=` `1``;`   `            ``# Change count to 0` `            ``count ``=` `0``;`   `    ``# If all last elements are equal` `    ``if` `(count !``=` `0``):` `        ``C ``+``=` `1``;`   `    ``count ``=` `0``;`   `    ``# Loop to run on even positions` `    ``for` `i ``in` `range``(``0``, n, ``2``):` `        ``if` `(X[i] !``=` `Y[i]):` `            ``count ``+``=` `1``;` `        ``else``:`   `            ``# Incrementing the` `            ``# global counter` `            ``if` `(count !``=` `0``):` `                ``C ``+``=` `1``;`   `            ``# Change count to 0` `            ``count ``=` `0``;`   `    ``if` `(count !``=` `0``):` `        ``C ``+``=` `1``;`   `    ``# Prthe minimum operations` `    ``print``(C);`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``X ``=` `[``1``, ``0``, ``0``, ``0``, ``0``, ``1``];` `    ``Y ``=` `[``1``, ``1``, ``0``, ``1``, ``1``, ``1``];` `    ``N ``=` `len``(X);`   `    ``# Function Call` `    ``minOperation(X, Y, N);`   `    ``# This code is contributed by 29AjayKumar `

 `// C# program for the above approach ` `using` `System;`   `class` `GFG{` `   `  `// Function to find the minimum flip` `// of subarrays required at alternate` `// index to make binary arrays equals` `static` `void` `minOperation(``int` `[]X, ``int` `[]Y,` `                         ``int` `n)` `{` `    `  `    ``// Stores count of total operations` `    ``int` `C = 0;` ` `  `    ``// Stores count of consecutive` `    ``// unequal elements` `    ``int` `count = 0;` ` `  `    ``// Loop to run on odd positions` `    ``for``(``int` `i = 1; i < n; i = i + 2)` `    ``{` `        ``if` `(X[i] != Y[i]) ` `        ``{` `            ``count++;` `        ``}` `        ``else` `        ``{` `            `  `            ``// Incrementing the` `            ``// global counter` `            ``if` `(count != 0)` `                ``C++;` ` `  `            ``// Change count to 0` `            ``count = 0;` `        ``}` `    ``}` ` `  `    ``// If all last elements are equal` `    ``if` `(count != 0)` `        ``C++;` ` `  `    ``count = 0;` ` `  `    ``// Loop to run on even positions` `    ``for``(``int` `i = 0; i < n; i = i + 2) ` `    ``{` `        ``if` `(X[i] != Y[i]) ` `        ``{` `            ``count++;` `        ``}` `        ``else` `        ``{` `            `  `            ``// Incrementing the` `            ``// global counter` `            ``if` `(count != 0)` `                ``C++;` ` `  `            ``// Change count to 0` `            ``count = 0;` `        ``}` `    ``}` ` `  `    ``if` `(count != 0)` `        ``C++;` ` `  `    ``// Print the minimum operations` `    ``Console.Write(C);` `}` `   `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]X = { 1, 0, 0, 0, 0, 1 };` `    ``int` `[]Y = { 1, 1, 0, 1, 1, 1 };` `    ``int` `N = X.Length;` `    `  `    ``// Function Call` `    ``minOperation(X, Y, N);` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:
`2`

Time Complexity: O(N)
Auxiliary Space: 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.

Article Tags :