Skip to content
Related Articles

Related Articles

Improve Article
Minimum prefixes required to be flipped to convert a Binary String to another
  • Difficulty Level : Expert
  • Last Updated : 28 May, 2021

Given two binary strings A and B of length N, the task is to convert the string from A to string B by repeatedly flipping all the bits of a prefix of A, i.e. convert all the 0s in the prefix to 1s and vice-versa and print the minimum number of prefix flips required and the length of respective prefixes.

Examples:

Input: A = “001”, B = “000”
Output: 
2
3 2
Explanation: 
Flipping the prefix “001” modifies the string to “110”.
Flipping the prefix “11” modifies the string to “000”.

Input: A = “1000”, B = “1011”
Output: 
2
4 2
Explanation: 
Flipping the prefix “1000” modifies the string to “0111”.
Flipping the prefix “01” modifies the string to “1011”.

 

Naive Approach: The simplest approach is to traverse the string A in reverse and for every ith character obtained such that A[i] is not equal to B[i], flip the characters present in A from indices [0, i] and increment the number of operations by 1. After complete traversal of the string, print the count of operations and the prefix length chosen in each operation.
Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach: The idea is to fix one bit at a time by traversing the string A in reverse. Maintain a boolean variable, say invert, initially set to false, to denote whether the current bits in A are flipped or not. While traversing, perform the following:



  • If the iᵗʰ bit in A is not equal to the iᵗʰ bit in B and invert is false, then increment the count of operations and set invert to true.
  • Otherwise, if the iᵗʰ bit in A is equal to the iᵗʰ bit in B and invert is true, then increment the count of operations and set invert to false.

Follow the steps below to solve the problem:

  • Initialize a boolean variable, say invert as false, to denote whether the bits in A are flipped or not.
  • Initialize an empty array, say res, to store the prefix length in each operation.
  • Iterate in the range [N – 1, 0] using the variable i and perform the following steps:
    • If A[i] != B[i] and invert is false, then the current bit is required to be flipped. Therefore. insert (i + 1) into the array res and update invert to true.
    • Otherwise, check if A[i] == B[i] and invert is true, then insert (i + 1) to res, and update invert to false.
  • Print the size of the array res as the number of operations required to make the two strings equal.
  • Then, print the values stored in res to denote the prefix length in each operation.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count flips required
// to make strings A and B equal
void findOperations(string A,
                    string B, int N)
{
    // Stores the count of the
    // number of operations
    int operations = 0;
 
    // Stores the length of
    // the chosen prefixes
    vector<int> ops;
 
    // Stores if operations are
    // performed even or odd times
    bool invert = false;
 
    // Traverse the given string
    for (int i = N - 1; i >= 0; i--) {
 
        // If current characters in
        // the two strings are unequal
        if (A[i] != B[i]) {
 
            // If A[i] is not flipped
            if (!invert) {
 
                // Increment count
                // of operations
                operations++;
 
                // Insert the length of
                // the chosen prefix
                ops.push_back(i + 1);
 
                // Update invert to true
                invert = true;
            }
        }
 
        else {
 
            // If A[i] is flipped
            if (invert) {
 
                // Increment count
                // of operations
                operations++;
 
                // Insert length of
                // the chosen prefix
                ops.push_back(i + 1);
 
                // Update invert to false
                invert = false;
            }
        }
    }
 
    // Print the number of
    // operations required
    cout << operations << endl;
 
    // Print the chosen prefix
    // length in each operation
    if (operations != 0) {
        for (auto x : ops)
            cout << x << " ";
    }
}
 
// Driver Code
int main()
{
    // Given binary strings
    string A = "001", B = "000";
    int N = A.size();
 
    findOperations(A, B, N);
 
    return 0;
}

Java




// Java program for the above approach
 
import java.util.*;
 
class GFG{
 
// Function to count flips required
// to make Strings A and B equal
static void findOperations(String A,
                    String B, int N)
{
    // Stores the count of the
    // number of operations
    int operations = 0;
 
    // Stores the length of
    // the chosen prefixes
    Vector<Integer> ops =  new Vector<>();
 
    // Stores if operations are
    // performed even or odd times
    boolean invert = false;
 
    // Traverse the given String
    for (int i = N - 1; i >= 0; i--) {
 
        // If current characters in
        // the two Strings are unequal
        if (A.charAt(i) != B.charAt(i)) {
 
            // If A[i] is not flipped
            if (!invert) {
 
                // Increment count
                // of operations
                operations++;
 
                // Insert the length of
                // the chosen prefix
                ops.add(i + 1);
 
                // Update invert to true
                invert = true;
            }
        }
 
        else {
 
            // If A[i] is flipped
            if (invert) {
 
                // Increment count
                // of operations
                operations++;
 
                // Insert length of
                // the chosen prefix
                ops.add(i + 1);
 
                // Update invert to false
                invert = false;
            }
        }
    }
 
    // Print the number of
    // operations required
    System.out.print(operations +"\n");
 
    // Print the chosen prefix
    // length in each operation
    if (operations != 0) {
        for (int x : ops)
            System.out.print(x+ " ");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    // Given binary Strings
    String A = "001", B = "000";
    int N = A.length();
 
    findOperations(A, B, N);
 
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python program for the above approach
 
# Function to count flips required
# to make strings A and B equal
def findOperations(A, B, N):
   
    # Stores the count of the
    # number of operations
    operations = 0
 
    # Stores the length of
    # the chosen prefixes
    ops = []
 
    # Stores if operations are
    # performed even or odd times
    invert = False
 
    # Traverse the given string
    for i in range(N - 1, -1, -1):
       
        # If current characters in
        # the two strings are unequal
        if (A[i] != B[i]):
 
            # If A[i] is not flipped
            if (not invert):
 
                # Increment count
                # of operations
                operations += 1
 
                # Insert the length of
                # the chosen prefix
                ops.append(i + 1)
 
                # Update invert to true
                invert = True
        else:
 
            # If A[i] is flipped
            if (invert):
 
                # Increment count
                # of operations
                operations += 1
 
                # Insert length of
                # the chosen prefix
                ops.append(i + 1)
 
                # Update invert to false
                invert = False
 
    # Print the number of
    # operations required
    print (operations)
 
    # Print the chosen prefix
    # length in each operation
    if (operations != 0):
        for x in ops:
            print(x, end = " ")
 
# Driver Code
if __name__ == '__main__':
   
    # Given binary strings
    A, B = "001", "000"
    N = len(A)
 
    findOperations(A, B, N)
 
# This code is contributed by mohit kumar 29.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to count flips required
// to make Strings A and B equal
static void findOperations(String A,
                           String B, int N)
{
     
    // Stores the count of the
    // number of operations
    int operations = 0;
 
    // Stores the length of
    // the chosen prefixes
    List<int> ops =  new List<int>();
 
    // Stores if operations are
    // performed even or odd times
    bool invert = false;
 
    // Traverse the given String
    for(int i = N - 1; i >= 0; i--)
    {
         
        // If current characters in
        // the two Strings are unequal
        if (A[i] != B[i])
        {
             
            // If A[i] is not flipped
            if (!invert)
            {
                 
                // Increment count
                // of operations
                operations++;
 
                // Insert the length of
                // the chosen prefix
                ops.Add(i + 1);
 
                // Update invert to true
                invert = true;
            }
        }
 
        else
        {
             
            // If A[i] is flipped
            if (invert)
            {
                 
                // Increment count
                // of operations
                operations++;
 
                // Insert length of
                // the chosen prefix
                ops.Add(i + 1);
 
                // Update invert to false
                invert = false;
            }
        }
    }
 
    // Print the number of
    // operations required
    Console.Write(operations + "\n");
 
    // Print the chosen prefix
    // length in each operation
    if (operations != 0)
    {
        foreach(int x in ops)
            Console.Write(x + " ");
    }
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Given binary Strings
    String A = "001", B = "000";
    int N = A.Length;
 
    findOperations(A, B, N);
}
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
      // JavaScript program for the above approach
      // Function to count flips required
      // to make Strings A and B equal
      function findOperations(A, B, N) {
        // Stores the count of the
        // number of operations
        var operations = 0;
 
        // Stores the length of
        // the chosen prefixes
        var ops = [];
 
        // Stores if operations are
        // performed even or odd times
        var invert = false;
 
        // Traverse the given String
        for (var i = N - 1; i >= 0; i--) {
          // If current characters in
          // the two Strings are unequal
          if (A[i] !== B[i]) {
            // If A[i] is not flipped
            if (!invert) {
              // Increment count
              // of operations
              operations++;
 
              // Insert the length of
              // the chosen prefix
              ops.push(i + 1);
 
              // Update invert to true
              invert = true;
            }
          } else {
            // If A[i] is flipped
            if (invert) {
              // Increment count
              // of operations
              operations++;
 
              // Insert length of
              // the chosen prefix
              ops.push(i + 1);
 
              // Update invert to false
              invert = false;
            }
          }
        }
 
        // Print the number of
        // operations required
        document.write(operations + "<br>");
 
        // Print the chosen prefix
        // length in each operation
        if (operations !== 0) {
          for (const x of ops) {
            document.write(x + " ");
          }
        }
      }
 
      // Driver Code
      // Given binary Strings
      var A = "001",
        B = "000";
      var N = A.length;
 
      findOperations(A, B, N);
    </script>
Output: 
2
3 2

 

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

 

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 industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :