Related Articles

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

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.

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

 ``

Output:
`2`

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

My Personal Notes arrow_drop_up