Skip to content
Related Articles

Related Articles

Check if two binary strings can be made equal by swapping 1s occurring before 0s

View Discussion
Improve Article
Save Article
  • Last Updated : 31 Mar, 2022

Given two binary strings str1 and str2 having same length, the task is to find if it is possible to make the two binary strings str1 and str2 equal by swapping all 1s occurring at indices less than that of 0s index in the binary string str1.

Examples:

Input: str1 = “0110”, str2 = “0011” 
Output: Possible 
Explanation:                                                                                                                                                                 
Swapping str1[2] with str1[3] the binary string str1 becomes “0101”. 
Swapping str1[1] with str1[2] the binary string str1 becomes “0011” .
The binary string str1 becomes equal to the binary string str2 therefore, the required output is Possible.

Input: str1 = “101”, str2 = “010” 
Output: Not Possible

Approach: The idea is to count the number of 1s and 0s in str1 and str2 and then proceed accordingly. Follow the steps below to solve the problem:

  • If the count of 1s and 0s are not equal in str1 and str2, then conversion is not possible.
  • Traverse the string.
  • Starting from the first character, compare each character one by one. For each different character at i, perform the following steps:
    • Check if the current character of the string str1 is ‘0’ and curStr1Ones (stores the current count of 1’s of the string str1) is greater than 0. If found to be true, then swap the character with ‘1’ and decrement the value of curStr1Ones by 1.
    • Check if the character of the string str1 is ‘0’ and curStr1Ones is equal to 0. If found to be true, then increment the value of the flag by 1 and break the loop.
    • Check if the character of the string str1 is ‘1’ and the character of the string str2 is ‘0’. If found to be true, then swap the character of str1 with ‘0’ and increment the value of curStr1Ones by 1.
  • Finally, print “Possible” if the flag is 0, otherwise print “Not Possible”.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if it is possible to make
// two binary strings equal by given operations
void isBinaryStringsEqual(string str1, string str2)
{
 
    // Stores count of 1's and 0's
    // of the string str1
    int str1Zeros = 0, str1Ones = 0;
 
    // Stores count of 1's and 0's
    // of the string str2
    int str2Zeros = 0, str2Ones = 0;
 
    int flag = 0;
 
    // Stores current count of 1's
    // present in the string str1
    int curStr1Ones = 0;
 
    // Count the number of 1's and 0's
    // present in the strings str1 and str2
    for (int i = 0; i < str1.length(); i++) {
 
        if (str1[i] == '1') {
            str1Ones++;
        }
 
        else if (str1[i] == '0') {
            str1Zeros++;
        }
 
        if (str2[i] == '1') {
            str2Ones++;
        }
 
        else if (str2[i] == '0') {
            str2Zeros++;
        }
    }
 
    // If the number of 1's and 0's
    // are not same of the strings str1
    // and str2 then print not possible
    if (str1Zeros != str2Zeros && str1Ones != str2Ones) {
        cout << "Not Possible";
    }
 
    else {
 
        // Traversing through the
        // strings str1 and str2
        for (int i = 0; i < str1.length(); i++) {
 
            // If the str1 character not
            // equals to str2 character
            if (str1[i] != str2[i]) {
 
                // Swaps 0 with 1 of the
                // string str1
                if (str1[i] == '0' && curStr1Ones > 0) {
                    str1[i] = '1';
                    curStr1Ones--;
                }
 
                // Breaks the loop as the count
                // of 1's is zero. Hence, no swaps possible
                if (str1[i] == '0' && curStr1Ones == 0) {
 
                    flag++;
                    break;
                }
 
                // Swaps 1 with 0 in the string str1
                if (str1[i] == '1' && str2[i] == '0') {
 
                    str1[i] = '0';
                    curStr1Ones++;
                }
            }
        }
 
        if (flag == 0) {
            cout << "Possible";
        }
 
        // Print not possible
        else {
            cout << "Not Possible";
        }
    }
}
 
// Driver Code
int main()
{
    // Given Strings
    string str1 = "0110";
    string str2 = "0011";
 
    // Function Call
    isBinaryStringsEqual(str1, str2);
 
    return 0;
}

Java



// Java program for the above approach
import java.io.*;
class GFG {
 
  // Function to check if it is possible to make
  // two binary strings equal by given operations
  static void isBinaryStringsEqual(String str1,
                                   String str2)
  {
 
    // Stores count of 1's and 0's
    // of the string str1
    int str1Zeros = 0, str1Ones = 0;
 
    // Stores count of 1's and 0's
    // of the string str2
    int str2Zeros = 0, str2Ones = 0;
    int flag = 0;
 
    // Stores current count of 1's
    // present in the string str1
    int curStr1Ones = 0;
 
    // Count the number of 1's and 0's
    // present in the strings str1 and str2
    for (int i = 0; i < str1.length(); i++)
    {
 
      if (str1.charAt(i) == '1')
      {
        str1Ones++;
      }
 
      else if (str1.charAt(i) == '0')
      {
        str1Zeros++;
      }
 
      if (str2.charAt(i) == '1')
      {
        str2Ones++;
      }
 
      else if (str2.charAt(i) == '0')
      {
        str2Zeros++;
      }
    }
 
    // If the number of 1's and 0's
    // are not same of the strings str1
    // and str2 then print not possible
    if (str1Zeros != str2Zeros
        && str1Ones != str2Ones)
    {
      System.out.println("Not Possible");
    }
 
    else {
 
      // Traversing through the
      // strings str1 and str2
      for (int i = 0; i < str1.length(); i++)
      {
 
        // If the str1 character not
        // equals to str2 character
        if (str1.charAt(i) != str2.charAt(i))
        {
 
          // Swaps 0 with 1 of the
          // string str1
          if (str1.charAt(i) == '0'
              && curStr1Ones > 0)
          {
            str1 = str1.substring(0, i) + '1'
              + str1.substring(i + 1);
            curStr1Ones--;
          }
 
          // Breaks the loop as the count
          // of 1's is zero. Hence, no swaps
          // possible
          if (str1.charAt(i) == '0'
              && curStr1Ones == 0)
          {
            flag++;
            break;
          }
 
          // Swaps 1 with 0 in the string str1
          if (str1.charAt(i) == '1'
              && str2.charAt(i) == '0')
          {
            str1 = str1.substring(0, i) + '0'
              + str1.substring(i+1);
            curStr1Ones++;
          }
        }
      }
 
      if (flag == 0) {
        System.out.println("Possible");
      }
 
      // Print not possible
      else {
        System.out.println("Not Possible");
      }
    }
  }
 
  // Driver Code
  public static void main(String[] args)
  {
 
    // Given Strings
    String str1 = "0110";
    String str2 = "0011";
 
    // Function Call
    isBinaryStringsEqual(str1, str2);
  }
}
 
// This code is contributed by dharanendralv23
Python3



# Python program for the above approach
 
# Function to check if it is possible to make
# two binary strings equal by given operations
def isBinaryStringsEqual(list1, list2) :
     
    str1 = list(list1)
    str2 = list(list2)
 
    # Stores count of 1's and 0's
    # of the string str1
    str1Zeros = 0
    str1Ones = 0
 
    # Stores count of 1's and 0's
    # of the string str2
    str2Zeros = 0
    str2Ones = 0
    flag = 0
 
    # Stores current count of 1's
    # present in the string str1
    curStr1Ones = 0
 
    # Count the number of 1's and 0's
    # present in the strings str1 and str2
    for i in range(len(str1)):
        if (str1[i] == '1') :
            str1Ones += 1
        elif (str1[i] == '0') :
            str1Zeros += 1
        if (str2[i] == '1') :
            str2Ones += 1
        elif (str2[i] == '0') :
            str2Zeros += 1
        
    # If the number of 1's and 0's
    # are not same of the strings str1
    # and str2 then print not possible
    if (str1Zeros != str2Zeros and str1Ones != str2Ones) :
        print("Not Possible")
    else :
 
        # Traversing through the
        # strings str1 and str2
        for i in range(len(str1)):
 
            # If the str1 character not
            # equals to str2 character
            if (str1[i] != str2[i]) :
 
                # Swaps 0 with 1 of the
                # string str1
                if (str1[i] == '0' and curStr1Ones > 0) :              
                    str1[i] = '1'
                    curStr1Ones -= 1
                 
                # Breaks the loop as the count
                # of 1's is zero. Hence, no swaps possible
                if (str1[i] == '0' and curStr1Ones == 0) :
                    flag += 1
                    break
                 
                # Swaps 1 with 0 in the string str1
                if (str1[i] == '1' and str2[i] == '0') :
                    str1[i] = '0'
                    curStr1Ones += 1
                 
        if (flag == 0) :
            print("Possible")
         
        # Print not possible
        else :
           print("Not Possible")
 
# Driver Code
 
# Given Strings
str1 = "0110"
str2 = "0011"
 
# Function Call
isBinaryStringsEqual(str1, str2)
 
# This code is contributed by mohit kumar 29.
C#



// C# program for the above approach
using System;
using System.Text;
class GFG
{
 
  // Function to check if it is possible to make
  // two binary strings equal by given operations
  static void isBinaryStringsEqual(string str1,
                                   string str2)
  {
 
    // Stores count of 1's and 0's
    // of the string str1
    int str1Zeros = 0, str1Ones = 0;
 
    // Stores count of 1's and 0's
    // of the string str2
    int str2Zeros = 0, str2Ones = 0;
    int flag = 0;
 
    // Stores current count of 1's
    // present in the string str1
    int curStr1Ones = 0;
 
    // Count the number of 1's and 0's
    // present in the strings str1 and str2
    for (int i = 0; i < str1.Length; i++)
    {
      if (str1[i] == '1')
      {
        str1Ones++;
      }
 
      else if (str1[i] == '0')
      {
        str1Zeros++;
      }
 
      if (str2[i] == '1')
      {
        str2Ones++;
      }
 
      else if (str2[i] == '0')
      {
        str2Zeros++;
      }
    }
 
    // If the number of 1's and 0's
    // are not same of the strings str1
    // and str2 then print not possible
    if (str1Zeros != str2Zeros
        && str1Ones != str2Ones)
    {
      Console.WriteLine("Not Possible");
    }
 
    else
    {
 
      // Traversing through the
      // strings str1 and str2
      for (int i = 0; i < str1.Length; i++)
      {
 
        // If the str1 character not
        // equals to str2 character
        if (str1[i] != str2[i])
        {
 
          // Swaps 0 with 1 of the
          // string str1
          if (str1[i] == '0' && curStr1Ones > 0)
          {
            StringBuilder sb
              = new StringBuilder(str1);
            sb[i] = '1';
            str1 = sb.ToString();
            curStr1Ones--;
          }
 
          // Breaks the loop as the count
          // of 1's is zero. Hence, no swaps
          // possible
          if (str1[i] == '0'
              && curStr1Ones == 0)
          {
            flag++;
            break;
          }
 
          // Swaps 1 with 0 in the string str1
          if (str1[i] == '1' && str2[i] == '0')
          {
            StringBuilder sb
              = new StringBuilder(str1);
            sb[i] = '0';
            str1 = sb.ToString();
            curStr1Ones++;
          }
        }
      }
 
      if (flag == 0)
      {
        Console.WriteLine("Possible");
      }
 
      // Print not possible
      else
      {
        Console.WriteLine("Not Possible");
      }
    }
  }
 
  // Driver Code
  static public void Main()
  {
 
    // Given Strings
    string str1 = "0110";
    string str2 = "0011";
 
    // Function Call
    isBinaryStringsEqual(str1, str2);
  }
}
 
// This code is contributed by dharanendralv23
Javascript



<script>
 
      // JavaScript program for the above approach
       
      // Function to check if it is possible to make
      // two binary strings equal by given operations
      function isBinaryStringsEqual(list1, list2) {
        var str1 = list1.split("");
        var str2 = list2.split("");
        // Stores count of 1's and 0's
        // of the string str1
        var str1Zeros = 0,
          str1Ones = 0;
 
        // Stores count of 1's and 0's
        // of the string str2
        var str2Zeros = 0,
          str2Ones = 0;
        var flag = 0;
 
        // Stores current count of 1's
        // present in the string str1
        var curStr1Ones = 0;
 
        // Count the number of 1's and 0's
        // present in the strings str1 and str2
        for (var i = 0; i < str1.length; i++) {
          if (str1[i] === "1") {
            str1Ones++;
          } else if (str1[i] === "0") {
            str1Zeros++;
          }
 
          if (str2[i] === "1") {
            str2Ones++;
          } else if (str2[i] === "0") {
            str2Zeros++;
          }
        }
 
        // If the number of 1's and 0's
        // are not same of the strings str1
        // and str2 then print not possible
        if (str1Zeros !== str2Zeros && str1Ones !== str2Ones) {
          document.write("Not Possible");
        } else {
          // Traversing through the
          // strings str1 and str2
          for (var i = 0; i < str1.length; i++) {
            // If the str1 character not
            // equals to str2 character
            if (str1[i] !== str2[i]) {
              // Swaps 0 with 1 of the
              // string str1
              if (str1[i] === "0" && curStr1Ones > 0) {
                str1[i] = "1";
 
                curStr1Ones--;
              }
 
              // Breaks the loop as the count
              // of 1's is zero. Hence, no swaps
              // possible
              if (str1[i] === "0" && curStr1Ones === 0) {
                flag++;
                break;
              }
 
              // Swaps 1 with 0 in the string str1
              if (str1[i] === "1" && str2[i] === "0") {
                str1[i] = "0";
                curStr1Ones++;
              }
            }
          }
 
          if (flag === 0) {
            document.write("Possible");
          }
 
          // Print not possible
          else {
            document.write("Not Possible");
          }
        }
      }
 
      // Driver Code
      // Given Strings
      var str1 = "0110";
      var str2 = "0011";
 
      // Function Call
      isBinaryStringsEqual(str1, str2);
       
</script>
Output
Possible
Time Complexity: O(|str1|) 
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Count array elements exceeding all previous elements as well as the next array element
Next

Maximum Spanning Tree using Prim’s Algorithm
Recommended Articles
Page :
Check if two binary strings can be made equal by swapping pairs of unequal characters
20, Jan 21
Check if given strings can be made same by swapping two characters of same or different strings
07, Dec 20
Check if two strings can be made equal by swapping one character among each other
20, Nov 19
Check if two strings can be made equal by swapping pairs of adjacent characters
03, Feb 21
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
Check if two strings can be made equal by reversing a substring of one of the strings
09, Dec 20
Check if two Binary Strings can be made equal by doing bitwise XOR of adjacent
20, Jul 22
Check if two non-duplicate strings can be made equal after at most two swaps in one string
14, Dec 21
Check if a string can be made equal to another string by swapping or replacement of characters
24, Jan 21
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Check whether two strings can be made equal by increasing prefixes
11, Nov 18
Check whether two strings can be made equal by copying their characters with the adjacent ones
09, Oct 19
Count of strings in Array A that can be made equal to strings in Array B by appending characters
15, Feb 22
Check if given Strings can be made equal by inserting at most 1 String
23, Jun 21
Check if Strings can be made equal by interchanging Characters
21, Jun 22
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Longest Substring that can be made a palindrome by swapping of characters
25, Dec 20
Check if two arrays can be made equal by reversing any subarray once
09, Jul 20
Minimum swaps to make two strings equal by swapping only with third string
04, Apr 20
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array
16, Sep 20
Check if all strings of an array can be made same by interchanging characters
15, Sep 20
Check whether the string S1 can be made equal to S2 with the given operation
13, Nov 19
Check if all characters of a string can be made equal by increments or decrements
05, May 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
dharanendralv23
@dharanendralv23
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!