Skip to content
Related Articles

Related Articles

Improve Article
Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal
  • Last Updated : 01 Jun, 2021

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++




// C++ program for the above approach
 
#include <bits/stdc++.h>
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[0]);
 
    // Function Call
    minOperation(X, Y, N);
 
    return 0;
}

Java




// 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

Python3




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




// 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

Javascript




<script>
// javascript program to implement
// the above approach
 
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
function minOperation(X, Y,
                         n)
{
      
    // Stores count of total operations
    let C = 0;
   
    // Stores count of consecutive
    // unequal elements
    let count = 0;
   
    // Loop to run on odd positions
    for(let 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(let 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
    document.write(C);
}
 
// Driver code
 
    let X = [ 1, 0, 0, 0, 0, 1 ];
    let Y = [ 1, 1, 0, 1, 1, 1 ];
    let N = X.length;
   
    // Function Call
    minOperation(X, Y, N);
    
   // This code is contributed by splevel62.
</script>
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.  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 industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :