Skip to content
Related Articles

Related Articles

Improve Article

Minimum number of flipping adjacent bits required to make given Binary Strings equal

  • Difficulty Level : Expert
  • Last Updated : 30 Aug, 2021

Given two binary strings s1[] and s2[] of the same length N, the task is to find the minimum number of operations to make them equal. Print -1 if it is impossible to do so. One operation is defined as choosing two adjacent indices of one of the binary string and inverting the characters at those positions, i.e, 1 to 0 and vice-versa.

Examples:

Input: s1[] = “0101”, s2[] = “1111”
Output: 2
Explanation: Invert the characters at 1 and 2 indices in the first string and at 0 and 1 indices in the second string to make them equal as 0011. There are other ways to do also like converting to 1111, etc.

Input: s1[] = “011”, s2[] = “111”
Output: -1 

Approach: The idea is to linearly traverse both strings and if at any index the characters are different than invert the ith and (i+1)th character in the string s1[]. Follow the steps below to solve the problem:



  • Initialize the variable count as 0 to store the answer.
  • Iterate over the range [0, N] using the variable i and perform the following steps:
    • If s1[i] is not equal to s2[i], then do the following tasks:
      • If s1[i] is equal to 1, then change it to 0, else, change it to 1.
      • Similarly, if s1[i+1] is equal to 1, then change it to 0, else, change it to 1.
      • Finally, increase the value of count by 1.
  • If s1[] is equal to s2[], then return the value of count as the answer else return -1.

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 number
// of inversions required.
int find_Min_Inversion(int n, string s1, string s2)
{
 
    // Initializing the answer
    int count = 0;
 
    // Iterate over the range
    for (int i = 0; i < n - 1; i++) {
        if (s1[i] != s2[i]) {
 
            // If s1[i]!=s2[i], then inverse
            // the characters at i snd (i+1)
            // positions in s1.
            if (s1[i] == '1') {
                s1[i] = '0';
            }
            else {
                s1[i] = '1';
            }
            if (s1[i + 1] == '1') {
                s1[i + 1] = '0';
            }
            else {
                s1[i + 1] = '1';
            }
 
            // Adding 1 to counter
            // if characters are not same
            count++;
        }
    }
    if (s1 == s2) {
        return count;
    }
    return -1;
}
 
// Driver Code
int main()
{
    int n = 4;
    string s1 = "0101";
    string s2 = "1111";
    cout << find_Min_Inversion(n, s1, s2) << endl;
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG {
 
    // Function to find the minimum number
    // of inversions required.
    static int find_Min_Inversion(int n, char[] s1, char[] s2) {
 
        // Initializing the answer
        int count = 0;
 
        // Iterate over the range
        for (int i = 0; i < n - 1; i++) {
            if (s1[i] != s2[i]) {
 
                // If s1[i]!=s2[i], then inverse
                // the characters at i snd (i+1)
                // positions in s1.
                if (s1[i] == '1') {
                    s1[i] = '0';
                } else {
                    s1[i] = '1';
                }
                if (s1[i + 1] == '1') {
                    s1[i + 1] = '0';
                } else {
                    s1[i + 1] = '1';
                }
 
                // Adding 1 to counter
                // if characters are not same
                count++;
            }
        }
         
        if (String.copyValueOf(s1).equals(String.copyValueOf(s2))) {
            return count;
        }
        return -1;
    }
 
    // Driver Code
    public static void main(String[] args) {
        int n = 4;
        String s1 = "0101";
        String s2 = "1111";
        System.out.print(find_Min_Inversion(n, s1.toCharArray(), s2.toCharArray()) + "\n");
    }
}
 
// This code is contributed by umadevi9616

Python3




# Python 3 program for the above approach
 
# Function to find the minimum number
# of inversions required.
def find_Min_Inversion(n, s1, s2):
   
    # Initializing the answer
    count = 0
 
    # Iterate over the range
    s1 = list(s1)
    s2 = list(s2)
    for i in range(n - 1):
        if (s1[i] != s2[i]):
 
            # If s1[i]!=s2[i], then inverse
            # the characters at i snd (i+1)
            # positions in s1.
            if (s1[i] == '1'):
                s1[i] = '0'
            else:
                s1[i] = '1'
            if (s1[i + 1] == '1'):
                s1[i + 1] = '0'
            else:
                s1[i + 1] = '1'
 
            # Adding 1 to counter
            # if characters are not same
            count += 1
    s1 = ''.join(s1)
    s2 = ''.join(s2)
    if (s1 == s2):
        return count
    return -1
 
# Driver Code
if __name__ == '__main__':
    n = 4
    s1 = "0101"
    s2 = "1111"
    print(find_Min_Inversion(n, s1, s2))
     
    # This code is contributed by SURENDRA_GANGWAR.

Javascript




<script>
// Java program for the above approach
// Function to find the minimum number
// of inversions required.
function find_Min_Inversion(n, s1, s2)
{
 
    // Initializing the answer
    let count = 0;
 
    // Iterate over the range
    for (let i = 0; i < n - 1; i++) {
        if (s1[i] != s2[i]) {
 
            // If s1[i]!=s2[i], then inverse
            // the characters at i snd (i+1)
            // positions in s1.
            if (s1[i] = '1') {
                s1[i] = '0';
            }
            else {
                s1[i] = '1';
            }
            if (s1[i + 1] = '1') {
                s1[i + 1] = '0';
            }
            else {
                s1[i + 1] = '1';
            }
 
            // Adding 1 to counter
            // if characters are not same
            count++;
        }
    }
    if (s1 != s2) {
        return count;
    }
     return -1;
}
 
// Driver Code
    let n = 4;
    let s1 = "0101";
    let s2 = "1111";
    document.write(find_Min_Inversion(n, s1, s2));
     
// This code is contributed by shivanisinghss2110
</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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :