Minimum substring flips required to convert a Binary String to another
Last Updated :
01 Jun, 2021
Given two binary strings S1 and S2 of size N and M respectively, the task is to find the minimum number of reversal of substrings of equal characters required to convert the string S1 to S2. If it is not possible to convert the string S1 to S2, then print “-1”.
Examples:
Input: S1 = “100001”, S2 = “110111”
Output: 2
Explanation:
Initially string S1 = “100001”.
Reversal 1: Reverse the substring S1[1, 1], then the string S1 becomes “110001”.
Reversal 2: Reverse the substring S1[3, 4], then the string S1 becomes “110111”.
After the above reversals, the string S1 and S2 are equal.
Therefore, the count of reversals is 2.
Input: S1 = 101, S2 = 10
Output: -1
Approach: Follow the below steps to solve this problem:
- Initialize a variable, say answer, to store the resultant count of reversal required.
- If the length of the given strings S1 and S2 are not the same, then print “-1”.
- Iterate over the range [0, N – 1] and perform the following steps:
- If S1[i] and S2[i] are not the same, then iterate till S1[i] and S2[i] are the same. Increment the answer by 1 as the current substring needs to be flipped.
- Otherwise, continue to the next iteration.
- After completing the above steps, print the value of the answer as the resultant flipping of substrings required.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int canMakeSame(string s1, string s2)
{
int ans = 0;
if (s1.size() != s2.size()) {
return -1;
}
int N = s1.length();
for ( int i = 0; i < N; i++) {
if (s1[i] != s2[i]) {
while (i < s1.length()
&& s1[i] != s2[i]) {
i++;
}
ans++;
}
}
return ans;
}
int main()
{
string S1 = "100001" ;
string S2 = "110111" ;
cout << canMakeSame(S1, S2);
return 0;
}
|
Java
import java.io.*;
class GFG
{
static int canMakeSame(String s1, String s2)
{
int ans = 0 ;
if (s1.length() != s2.length()) {
return - 1 ;
}
int N = s1.length();
for ( int i = 0 ; i < N; i++)
{
if (s1.charAt(i) != s2.charAt(i))
{
while (i < s1.length()
&& s1.charAt(i) != s2.charAt(i))
{
i++;
}
ans++;
}
}
return ans;
}
public static void main(String[] args)
{
String S1 = "100001" ;
String S2 = "110111" ;
System.out.println(canMakeSame(S1, S2));
}
}
|
Python3
def canMakeSame(s1, s2) :
ans = - 1
if ( len (s1) ! = len (s2)) :
return - 1
N = len (s1)
for i in range ( 0 , N):
if (s1[i] ! = s2[i]) :
while (i < len (s1)
and s1[i] ! = s2[i]) :
i + = 1
ans + = 1
return ans
S1 = "100001"
S2 = "110111"
print (canMakeSame(S1, S2))
|
C#
using System;
class GFG{
static int canMakeSame( string s1, string s2)
{
int ans = 0;
if (s1.Length != s2.Length) {
return -1;
}
int N = s1.Length;
for ( int i = 0; i < N; i++)
{
if (s1[i] != s2[i])
{
while (i < s1.Length
&& s1[i] != s2[i])
{
i++;
}
ans++;
}
}
return ans;
}
public static void Main( string [] args)
{
string S1 = "100001" ;
string S2 = "110111" ;
Console.Write(canMakeSame(S1, S2));
}
}
|
Javascript
<script>
function canMakeSame(s1, s2)
{
var ans = 0;
if (s1.length != s2.length) {
return -1;
}
var N = s1.length;
for ( var i = 0; i < N; i++) {
if (s1[i] != s2[i]) {
while (i < s1.length
&& s1[i] != s2[i]) {
i++;
}
ans++;
}
}
return ans;
}
var S1 = "100001" ;
var S2 = "110111" ;
document.write( canMakeSame(S1, S2));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Share your thoughts in the comments
Please Login to comment...