 Open in App
Not now

# Check if a string can be converted to another given string by removal of a substring

• Last Updated : 08 Sep, 2021

Given two strings S and T of length N and M respectively, the task is to check if the string S can be converted to the string T by removing at most one substring of the string S. If found to be true, then print “YES”. Otherwise, print “NO”.

Example:

Input: S = “abcdef”, T = “abc”
Output: YES
Explanation:
Removing the substring { S, …, S } modifies S to “abc”.
Since the string S equal to T, the required output is “YES”.

Input: S = “aaabbb”, T = “ab”
Output: YES
Explanation:
Removing the substring { S, …, S } modifies S to “ab”.
Since the string S equal to T, the required output is “YES”.

Naive Approach: The simplest approach to solve this problem is to generate all possible substrings of the string S and for each substring, check if its removal makes the string S equal to the string T or not. If found to be true for any string, then print “YES”. Otherwise, print “NO”
Time complexity: O(N2 * M)
Auxiliary space: O(1)

Efficient Approach: The above approach can be optimized based on the following observations:

If the substring { S, …, S[i] } + { S[N – (M – i)], …, S[N – 1] } is equal to T, only then, string S can be converted to the string T.

Follow the steps below to solve the problem:

• Iterate over the range [0, M] and check if the substring { S, …, S[i] } + { S[N – (M – i)], …, S[N – 1] } is equal to T or not. If found to be true, then print “YES”.
• Otherwise, print “NO”.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to check if S can be converted to T` `// by removing at most one substring from S` `string make_string_S_to_T(string S, string T)` `{` `    ``// Check if S can be converted to T by` `    ``// removing at most one substring from S` `    ``bool` `possible = ``false``;`   `    ``// Stores length of string T` `    ``int` `M = T.length();`   `    ``// Stores length of string S` `    ``int` `N = S.length();`   `    ``// Iterate over the range [0, M - 1]` `    ``for` `(``int` `i = 0; i <= M; i++) {`   `        ``// Stores Length of the substring` `        ``// { S, ..., S[i] }` `        ``int` `prefix_length = i;`   `        ``// Stores Length of the substring` `        ``// { S, ..., S[i] }` `        ``int` `suffix_length = M - i;`   `        ``// Stores prefix substring` `        ``string prefix` `            ``= S.substr(0, prefix_length);`   `        ``// Stores suffix substring` `        ``string suffix` `            ``= S.substr(N - suffix_length,` `                       ``suffix_length);`   `        ``// Checking if prefix+suffix == T` `        ``if` `(prefix + suffix == T) {` `            ``possible = ``true``;` `            ``break``;` `        ``}` `    ``}`   `    ``if` `(possible)` `        ``return` `"YES"``;` `    ``else` `        ``return` `"NO"``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given String S and T` `    ``string S = ``"ababcdcd"``;` `    ``string T = ``"abcd"``;`   `    ``// Function call` `    ``cout << make_string_S_to_T(S, T);` `    ``return` `0;` `}`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG` `{`   `// Function to check if S can be converted to T` `// by removing at most one subString from S` `static` `String make_String_S_to_T(String S, String T)` `{` `  `  `    ``// Check if S can be converted to T by` `    ``// removing at most one subString from S` `    ``boolean` `possible = ``false``;`   `    ``// Stores length of String T` `    ``int` `M = T.length();`   `    ``// Stores length of String S` `    ``int` `N = S.length();`   `    ``// Iterate over the range [0, M - 1]` `    ``for` `(``int` `i = ``0``; i <= M; i++)` `    ``{`   `        ``// Stores Length of the subString` `        ``// { S, ..., S[i] }` `        ``int` `prefix_length = i;`   `        ``// Stores Length of the subString` `        ``// { S, ..., S[i] }` `        ``int` `suffix_length = M - i;`   `        ``// Stores prefix subString` `        ``String prefix` `            ``= S.substring(``0``, prefix_length);`   `        ``// Stores suffix subString` `        ``String suffix` `            ``= S.substring(N - suffix_length,` `                       ``N);`   `        ``// Checking if prefix+suffix == T` `        ``if` `((prefix + suffix).equals(T))` `        ``{` `            ``possible = ``true``;` `            ``break``;` `        ``}` `    ``}` `    ``if` `(possible)` `        ``return` `"YES"``;` `    ``else` `        ``return` `"NO"``;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  `  `    ``// Given String S and T` `    ``String S = ``"ababcdcd"``;` `    ``String T = ``"abcd"``;`   `    ``// Function call` `    ``System.out.print(make_String_S_to_T(S, T));` `}` `}`   `// This code is contributed by shikhasingrajput`

## Python3

 `# Python program for the above approach`   `# Function to check if S can be converted to T` `# by removing at most one substring from S` `def` `make_string_S_to_T(S, T):` `    `  `    ``# Check if S can be converted to T by` `    ``# removing at most one substring from S` `    ``possible ``=` `False` `    `  `    ``# Stores length of string T` `    ``M ``=` `len``(T)` `    `  `    ``# Stores length of string S` `    ``N ``=` `len``(S)` `    `  `    ``# Iterate over the range [0, M - 1]` `    ``for` `i ``in` `range``(``0``,M``+``1``):` `        `  `        ``# Stores Length of the substring` `        ``#  S, ..., S[i] ` `        ``prefix_length ``=` `i` `        `  `        ``# Stores Length of the substring` `        ``#  S, ..., S[i] ` `        ``suffix_length ``=` `M ``-` `i` `        `  `        ``# Stores prefix substring` `        ``prefix ``=` `S[:prefix_length]` `        `  `        ``# Stores suffix substring` `        ``suffix ``=` `S[N ``-` `suffix_length:N]` `        `  `        ``# Checking if prefix+suffix == T` `        ``if` `(prefix ``+` `suffix ``=``=` `T):` `            ``possible ``=` `True` `            ``break` `    `  `    ``if` `(possible):` `        ``return` `"YES"` `    ``else``:` `        ``return` `"NO"`   `# Driver Code`   `# Given String S and T` `S ``=` `"ababcdcd"` `T ``=` `"abcd"`   `# Function call` `print``(make_string_S_to_T(S, T))`   `# This code is contributed by shubhamsingh10`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `public` `class` `GFG` `{`   `// Function to check if S can be converted to T` `// by removing at most one subString from S` `static` `String make_String_S_to_T(String S, String T)` `{` `  `  `    ``// Check if S can be converted to T by` `    ``// removing at most one subString from S` `    ``bool` `possible = ``false``;`   `    ``// Stores length of String T` `    ``int` `M = T.Length;`   `    ``// Stores length of String S` `    ``int` `N = S.Length;`   `    ``// Iterate over the range [0, M - 1]` `    ``for` `(``int` `i = 0; i <= M; i++)` `    ``{`   `        ``// Stores Length of the subString` `        ``// { S, ..., S[i] }` `        ``int` `prefix_length = i;`   `        ``// Stores Length of the subString` `        ``// { S, ..., S[i] }` `        ``int` `suffix_length = M - i;`   `        ``// Stores prefix subString` `        ``String prefix` `            ``= S.Substring(0, prefix_length);`   `        ``// Stores suffix subString` `        ``String suffix` `            ``= S.Substring(N-suffix_length,` `                       ``suffix_length);`   `        ``// Checking if prefix+suffix == T` `        ``if` `((prefix + suffix).Equals(T))` `        ``{` `            ``possible = ``true``;` `            ``break``;` `        ``}` `    ``}` `    ``if` `(possible)` `        ``return` `"YES"``;` `    ``else` `        ``return` `"NO"``;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  `  `    ``// Given String S and T` `    ``String S = ``"ababcdcd"``;` `    ``String T = ``"abcd"``;`   `    ``// Function call` `    ``Console.Write(make_String_S_to_T(S, T));` `}` `}`   `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

`YES`

Time complexity: O(M2)
Auxiliary space: O(M)

My Personal Notes arrow_drop_up
Related Articles