Minimum substring flips required to convert given binary string to another - GeeksforGeeks

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:
Input: A = “0010”, B = “1011”Output; 3Explanation:Step 1: Flip the entire string A. Therefore, A becomes “1101” .Step 2: Flip the substring {A[0], A[2]}. Therefore, A becomes “0011” .Step 3: Flip A[0]. Therefore, A becomes “1011” which is equal to B.Therefore, the minimum number of operations required is 3.
Input: A = “1010101”, B = “0011100”Output: 5Explanation:Step 1: Flip the entiThehrefore, A becomes “0101010′′Step 2: Flip substring {A[0], A[5]}. Therefore, A becomes “1010100′′Step 3: Flip the substring {A[0], A[3]}. Therefore, A becomes “0101100′′Step 4: Flip the substring {A[0], A[2]}. Therefore, A becomes “1011100′′Step 5: Flip A[0]. 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++
Java
Python3
C#
Javascript
// C++ program for the above approach #include <bits/stdc++.h>using namespace std; // Function that finds the minimum// number of operations required such// that string A and B are the samevoid 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 Codeint main(){    // Given strings A and B    string A = "101010", B = "110011";     // Function Call    findMinimumOperations(A, B);     return 0;}
// Java program for the// above approachimport java.util.*;class GFG{ // Function that finds the minimum// number of operations required such// that String A and B are the samestatic 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 Codepublic 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 program for the above approach # Function that finds the minimum# number of operations required such# that string A and B are the samedef 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 Codeif __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# program for the// above approachusing System; class GFG{ // Function that finds the minimum// number of operations required such// that string A and B are the samestatic 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 Codepublic 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
<script> // JavaScript program for the// above approach // Function that finds the minimum// number of operations required such// that string A and B are the samefunction findMinimumOperations(a, b){         // Stores the count of steps    var step = 0;         // Stores the last index whose    // bits are not same    var last_index = 0;         // Iterate until both string    // are unequal    while (a !== b)    {                 // Check till end of string to        // find rightmost unequals bit        for (var 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        var ch = a.split("");        for(var i = 0; i <= last_index; i++)        {                         // Flip the bit            if (ch[i] === "0")            {                ch[i] = "1";            }            else            {                ch[i] = "0";            }        }        a = ch.join("");                 // Increasing steps by one        step++;    }         // Print the count of steps    document.write(step);} // Driver Code // Given strings A and Bvar A = "101010";var B = "110011"; // Function CallfindMinimumOperations(A, B); // This code is contributed by rdtank </script>
4
 
Time Complexity: O(N2)Auxiliary Space: O(1)
mohit kumar 29
29AjayKumar
SURENDRA_GANGWAR
rdtank
adnanirshad158
binary-string
substring
Greedy
Searching
Strings
Searching
Strings
Greedy
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Optimal Page Replacement Algorithm
Program for Best Fit algorithm in Memory Management
Program for First Fit algorithm in Memory Management
Bin Packing Problem (Minimize number of used Bins)
Max Flow Problem Introduction
Binary Search
Maximum and minimum of an array using minimum number of comparisons
Linear Search
Search an element in a sorted and rotated array
Find the Missing Number