Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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[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: 5
Explanation:
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++




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



<script>
 
// JavaScript program for the
// above approach
 
// Function that finds the minimum
// number of operations required such
// that string A and B are the same
function 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 B
var A = "101010";
var B = "110011";
 
// Function Call
findMinimumOperations(A, B);
 
// This code is contributed by rdtank
 
</script>
Output: 
4
 
Time Complexity: O(N2)
Auxiliary Space: O(1)



My Personal Notes
arrow_drop_up
Previous
Maximum even sum subsequence of length K
Next

Count pairs having Bitwise XOR less than K from given array
Recommended Articles
Page :
Minimum substring flips required to convert a Binary String to another
01, Mar 21
Minimum flips required in a binary string such that all K-size substring contains 1
24, Jun 20
Minimum flips or swapping of adjacent characters required to make a string equal to another
09, Jun 21
Minimum flips required to convert given string into concatenation of equal substrings of length K
21, Jul 20
Minimum Subarray flips required to convert all elements of a Binary Array to K
19, Aug 20
Minimum flips required to form given binary string where every flip changes all bits to its right as well
14, Jun 20
Minimum flips required to keep all 1s together in a Binary string
19, May 20
Minimum non-adjacent pair flips required to remove all 0s from a Binary String
22, Sep 20
Minimum Count of Bit flips required to make a Binary String Palindromic
12, Aug 20
Minimum number of given operations required to convert a string to another string
07, Feb 19
Minimum increments by 1 or K required to convert a string into another given string
23, Feb 21
Minimize flips to make binary string as all 1s by flipping characters in substring of size K repeatedly
10, Sep 21
Minimize count of flips required such that no substring of 0s have length exceeding K
01, Sep 20
Minimum swaps required to convert one binary string to another
31, Oct 18
Minimum prefixes required to be flipped to convert a Binary String to another
11, May 21
Minimum flips to remove any consecutive 3 0s or 1s in given Binary string
27, Aug 21
Minimum substring reversals required to make given Binary String alternating
16, Dec 20
Minimum number of subsequences required to convert one string to another
03, Feb 20
Minimum number of subsequences required to convert one string to another using Greedy Algorithm
27, Feb 20
Minimize flips required to make all shortest paths from top-left to bottom-right of a binary matrix equal to S
04, Sep 20
Minimum number of flips to make a Binary String increasing
13, Aug 21
Minimum number of flips with rotation to make binary string alternating
24, Aug 20
Minimum given operations required to convert a given binary string to all 1's
09, Sep 19
Minimum flips required to generate continuous substrings of 0’s and 1’s
31, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
mohammaderfangooneh
@mohammaderfangooneh
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!