 GeeksforGeeks App
Open App Browser
Continue

# Make Binary Strings equal by replacing 2nd bit repeatedly

Given two binary strings S and T of size N and M respectively, the task is to check if S can be converted into T by doing the following operations, any number of times:

• Suppose a is the first character of S and b is the second character of S.
• Change the second character of S to either min(a, b) or max(a, b),
• and remove the first character.
• Note that the length of the string reduces by 1 after each operation.

Examples:

Input: S = “001001” , T = “11”
Output: YES
Explanation: Just do the max operation (change second character of S to max(first character, second character) and remove the first character 4 times on the string S.

• 001001″  ->  “01001″
• 01001″  -> “1001″
• 1001″  -> “101″
•  “101″  -> “11″ , which is equal to the string T

Input: S = “000001” , T = “11”
Output: NO

Approach:

• It can be observed that only initial N – M + 1 elements of S can be modified (else length of S would not be equal to T).
• Therefore, the substring S[N – M + 2]…S[N] must be equal to T…T[M]
• And for the first element of T, if it is 0, min operation can be used on the elements of S.
• Else, the max operation can be used.

So it would be sufficient to check whether any of the initial N – M + 1 elements of S equals first element of T.

Based on the above observation, the following approach can be used to solve the problem :

• If the length of S is less than the length of T, return false.
• Iterate from i = 1 to M – 1 and check if S[i + N – M] is equal to T[i] at each iteration. If not so, return false.
• Iterate from 0 to N – M and check if S[i] is equal to T at any iteration and above conditions are satisfied, return true.

Below is the implementation of this approach:

## C++

```// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to check if it is possible to
// convert a string into another string by
// doing the given operation
bool isPossible(string S, string T)
{
int N = S.size(), M = T.size();

// If size of S is less than size of T,
// then the conversion is not possible
if (N < M) {
return false;
}

// Checking if the substring
// S(N + M - 2...N) is equal to
// T(1...M)
for (int i = 1; i < M; i++) {
if (S[i + N - M] != T[i]) {
return false;
}
}

// Checking if any element in the
// substring S(0..N-M+1) is
// equal to T
for (int i = 0; i < N - M + 1; i++) {
if (S[i] == T) {
return true;
}
}
return false;
}

// Driver Code
int main()
{
string S = "001001";
string T = "11";

// Function Call
cout << "YES";
}
else {
cout << "NO";
}
}```

## Java

```// Java code for the above approach
import java.io.*;

class GFG {
// Function to check if it is possible to
// convert a string into another string by
// doing the given operation
public static boolean isPossible(String S, String T)
{
int N = S.length(), M = T.length();

// If size of S is less than size of T,
// then the conversion is not possible
if (N < M) {
return false;
}

// Checking if the substring
// S(N + M - 2...N) is equal to
// T(1...M)
for (int i = 1; i < M; i++) {
if (S.charAt(i + N - M) != T.charAt(i)) {
return false;
}
}

// Checking if any element in the
// substring S(0..N-M+1) is
// equal to T
for (int i = 0; i < N - M + 1; i++) {
if (S.charAt(i) == T.charAt(0)) {
return true;
}
}
return false;
}

// Driver Code
public static void main(String[] args)
{
String S = "001001";
String T = "11";

// Function Call
System.out.print("YES");
}
else {
System.out.print("NO");
}
}
}

// This code is contributed by Rohit Pradhan```

## Python3

```# Python3 code for the above approach

# Function to check if it is possible to
# convert a string into another string by
# doing the given operation
def isPossible(S, T) :

N = len(S);
M = len(T);

# If size of S is less than size of T,
# then the conversion is not possible
if (N < M) :
return False;

# Checking if the substring
# S(N + M - 2...N) is equal to
# T(1...M)
for i in range(1, M) :
if (S[i + N - M] != T[i]) :
return False;

# Checking if any element in the
# substring S(0..N-M+1) is
# equal to T
for i in range(N - M + 1) :
if (S[i] == T) :
return True;

return False;

# Driver Code
if __name__ == "__main__" :

S = "001001";
T = "11";

# Function Call
print("YES");

else :
print("NO");

# This code is contributed by AnkThon```

## C#

```// C# code for the above approach
using System;

class GFG
{

// Function to check if it is possible to
// convert a string into another string by
// doing the given operation
public static bool isPossible(string S, string T)
{
int N = S.Length, M = T.Length;

// If size of S is less than size of T,
// then the conversion is not possible
if (N < M) {
return false;
}

// Checking if the substring
// S(N + M - 2...N) is equal to
// T(1...M)
for (int i = 1; i < M; i++) {
if (S[i + N - M] != T[i]) {
return false;
}
}

// Checking if any element in the
// substring S(0..N-M+1) is
// equal to T
for (int i = 0; i < N - M + 1; i++) {
if (S[i] == T) {
return true;
}
}
return false;
}

// Driver Code
public static void Main(String[] args)
{
String S = "001001";
String T = "11";

// Function Call
Console.WriteLine("YES");
}
else {
Console.WriteLine("NO");
}
}
}

// This code is contributed by Tapesh (tapeshdua420)```

## Javascript

```<script>
// Javascript code for the above approach

// Function to check if it is possible to
// convert a string into another string by
// doing the given operation
function isPossible(S, T) {
let N = S.length, M = T.length;

// If size of S is less than size of T,
// then the conversion is not possible
if (N < M) {
return false;
}

// Checking if the substring
// S(N + M - 2...N) is equal to
// T(1...M)
for (let i = 1; i < M; i++) {
if (S[i + N - M] != T[i]) {
return false;
}
}

// Checking if any element in the
// substring S(0..N-M+1) is
// equal to T
for (let i = 0; i < N - M + 1; i++) {
if (S[i] == T) {
return true;
}
}
return false;
}

// Driver Code
let S = "001001";
let T = "11";

// Function Call
document.write("YES");
}
else {
document.write("NO");
}

// This code is contributed by saurabh_jaiswal.
</script>```
Output

`YES`

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

My Personal Notes arrow_drop_up