# Minimum substring flips required to convert given binary string to another

• Last Updated : 11 Jun, 2021

Given two binary strings A and B, the task is to find the minimum number of times a substring starting from the first character of A needs to be flipped, i.e. convert 1s to 0s and 0s to 1s, to convert A to B.

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: A = “0010”, B = “1011”
Output; 3
Explanation:
Step 1: Flip the entire string A. Therefore, A becomes “1101” .
Step 2: Flip the substring {A, A}. Therefore, A becomes “0011” .
Step 3: Flip A. Therefore, A becomes “1011” which is equal to B.
Therefore, the minimum number of operations required is 3.

Input: A = “1010101”, B = “0011100”
Output: 5
Explanation:
Step 1: Flip the entiThehrefore, A becomes “0101010″
Step 2: Flip substring {A, A}. Therefore, A becomes “1010100″
Step 3: Flip the substring {A, A}. Therefore, A becomes “0101100″
Step 4: Flip the substring {A, A}. Therefore, A becomes “1011100″
Step 5: Flip A. Therefore, A becomes “0011100” which is equal to B.
Therefore, the minimum number of operations required is 5.

Approach: The idea is to initialize a variable that holds the last index at which character at A is different from the character at B. Then negate A from the 1st index to the last index. Repeat until both strings become equal. Follow the steps below to solve the problem:

• Initialize a variable last_index that holds the last index at which characters are different in A and B.
• Negate string A from the 1st index to last_index and increment the count of steps.
• Repeat the above steps until string A becomes equal to string B.
• Print the count of steps after both the strings are the same after performing the operations.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function that finds the minimum``// number of operations required such``// that string A and B are the same``void` `findMinimumOperations(string a,``                           ``string b)``{` `    ``// Stores the count of steps``    ``int` `step = 0;` `    ``// Stores the last index whose``    ``// bits are not same``    ``int` `last_index;` `    ``// Iterate until both string``    ``// are unequal``    ``while` `(a != b) {` `        ``// Check till end of string to``        ``// find rightmost unequals bit``        ``for` `(``int` `i = 0;``             ``i < a.length(); i++) {` `            ``// Update the last index``            ``if` `(a[i] != b[i]) {``                ``last_index = i;``            ``}``        ``}` `        ``// Flipping characters up``        ``// to the last index``        ``for` `(``int` `i = 0;``             ``i <= last_index; i++) {` `            ``// Flip the bit``            ``a[i] = (a[i] == ``'0'``) ? ``'1'` `: ``'0'``;``        ``}` `        ``// Increasing steps by one``        ``step++;``    ``}` `    ``// Print the count of steps``    ``cout << step;``}` `// Driver Code``int` `main()``{``    ``// Given strings A and B``    ``string A = ``"101010"``, B = ``"110011"``;` `    ``// Function Call``    ``findMinimumOperations(A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{` `// Function that finds the minimum``// number of operations required such``// that String A and B are the same``static` `void` `findMinimumOperations(``char``[] a,``                                  ``char``[] b)``{``  ``// Stores the count of steps``  ``int` `step = ``0``;` `  ``// Stores the last index whose``  ``// bits are not same``  ``int` `last_index = ``0``;` `  ``// Iterate until both String``  ``// are unequal``  ``while` `(!Arrays.equals(a, b))``  ``{``    ``// Check till end of String to``    ``// find rightmost unequals bit``    ``for` `(``int` `i = ``0``;``             ``i < a.length; i++)``    ``{``      ``// Update the last index``      ``if` `(a[i] != b[i])``      ``{``        ``last_index = i;``      ``}``    ``}` `    ``// Flipping characters up``    ``// to the last index``    ``for` `(``int` `i = ``0``;``             ``i <= last_index; i++)``    ``{` `      ``// Flip the bit``      ``a[i] = (a[i] == ``'0'``) ?``              ``'1'` `: ``'0'``;``    ``}``    ``// Increasing steps by one``    ``step++;``  ``}` `  ``// Print the count of steps``  ``System.out.print(step);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``// Given Strings A and B``    ``String A = ``"101010"``,``           ``B = ``"110011"``;` `    ``// Function Call``    ``findMinimumOperations(A.toCharArray(),``                          ``B.toCharArray());``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach` `# Function that finds the minimum``# number of operations required such``# that string A and B are the same``def` `findMinimumOperations(a, b):``    ` `    ``# Stores the count of steps``    ``step ``=` `0` `    ``# Stores the last index whose``    ``# bits are not same``    ``last_index ``=` `0` `    ``# Iterate until both string``    ``# are unequal``    ``while` `(a !``=` `b):``        ``a ``=` `[i ``for` `i ``in` `a]``        ` `        ``# Check till end of string to``        ``# find rightmost unequals bit``        ``for` `i ``in` `range``(``len``(a)):``            ` `            ``# Update the last index``            ``if` `(a[i] !``=` `b[i]):``                ``last_index ``=` `i` `        ``# Flipping characters up``        ``# to the last index``        ``for` `i ``in` `range``(last_index ``+` `1``):``            ` `            ``# Flip the bit``            ``if` `(a[i] ``=``=` `'0'``):``                ``a[i] ``=` `'1'``            ``else``:``                ``a[i] ``=` `'0'``                ` `        ``a ``=` `"".join(a)       ` `        ``# Increasing steps by one``        ``step ``+``=` `1` `    ``# Print the count of steps``    ``print``(step)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given strings A and B``    ``A ``=` `"101010"``    ``B ``=` `"110011"` `    ``# Function Call``    ``findMinimumOperations(A, B)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System;` `class` `GFG{` `// Function that finds the minimum``// number of operations required such``// that string A and B are the same``static` `void` `findMinimumOperations(``string` `a,``                                  ``string` `b)``{``  ` `  ``// Stores the count of steps``  ``int` `step = 0;` `  ``// Stores the last index whose``  ``// bits are not same``  ``int` `last_index = 0;` `  ``// Iterate until both string``  ``// are unequal``  ``while` `(a.Equals(b) == ``false``)``  ``{``    ` `    ``// Check till end of string to``    ``// find rightmost unequals bit``    ``for``(``int` `i = 0; i < a.Length; i++)``    ``{``      ` `      ``// Update the last index``      ``if` `(a[i] != b[i])``      ``{``        ``last_index = i;``      ``}``    ``}` `    ``// Flipping characters up``    ``// to the last index``    ``char``[] ch = a.ToCharArray();``    ``for``(``int` `i = 0;``            ``i <= last_index; i++)``    ``{``      ` `      ``// Flip the bit``      ``if` `(ch[i] == ``'0'``)``      ``{``        ``ch[i] = ``'1'``;``      ``}``      ``else``      ``{``        ``ch[i] = ``'0'``;``      ``}``    ``}``    ``a = ``new` `string``(ch);``    ` `    ``// Increasing steps by one``    ``step++;``  ``}` `  ``// Print the count of steps``  ``Console.WriteLine(step);``}` `// Driver Code``public` `static` `void` `Main()``{``  ` `  ``// Given strings A and B``  ``string` `A = ``"101010"``;``  ``string` `B = ``"110011"``;` `  ``// Function Call``  ``findMinimumOperations(A,B);``}``}` `// This code is contributed by SURENDRA_GANGWAR`

## Javascript

 ``
Output:
`4`

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

My Personal Notes arrow_drop_up