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

• Difficulty Level : Expert
• Last Updated : 04 Jul, 2022

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

## C

 `// C program for the above approach``#include ``#include ` `// Function to find the minimum number``// of inversions required.``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` `(``strcmp``(s1, s2) != -1) {``        ``return` `count;``    ``}``    ``return` `-1;``}` `// Driver Code``int` `main()``{``    ``int` `n = 4;``    ``char` `s1 = ``"0101"``;``    ``char` `s2 = ``"1111"``;``    ``printf``(``"%d\n"``, find_Min_Inversion(n, s1, s2));``    ``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.`

## C#

 `// C# program for the above approach``using` `System;` `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` `(``new` `string``(s1) == ``new` `string``(s2)) {``      ``return` `count;``    ``}``    ``return` `-1;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `n = 4;``    ``string` `s1 = ``"0101"``;``    ``string` `s2 = ``"1111"``;` `    ``// Function call``    ``Console.Write(find_Min_Inversion(n,``                                     ``s1.ToCharArray(),``                                     ``s2.ToCharArray())``                  ``+ ``"\n"``);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up