 Open in App
Not now

# Check if two strings can be made equal by reversing a substring of one of the strings

• Last Updated : 25 Mar, 2023

Given two strings X and Y of length N, the task is to check if both the strings can be made equal by reversing any substring of X exactly once. If it is possible, then print “Yes”. Otherwise, print “No”.

Examples:

Input: X = “adcbef”, Y = “abcdef”
Output: Yes
Explanation: Strings can be made equal by reversing the substring “dcb” of string X.

Input: X = “126543”, Y = “123456”
Output: Yes
Explanation: Strings can be made equal by reversing the substring “6543” of string X.

Brute Force Approach:

The brute force approach to solve this problem would be to try every possible substring of X and reverse it, and then check if the reversed substring when replaced in X makes it equal to Y.

The steps for this approach are:

1. Iterate through every substring of X.
2. Reverse the substring and replace it in X.
3. Check if the modified X is equal to Y. If it is, print “Yes” and return from the function.
4. If the modified X is not equal to Y after iterating through all the substrings, print “No”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to check if the strings` `// can be made equal or not by` `// reversing a substring of X` `bool` `checkString(string X, string Y)` `{` `    ``int` `n = X.length();` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = i; j < n; j++) {` `            ``reverse(X.begin() + i, X.begin() + j + 1);` `            ``if` `(X == Y) {` `                ``cout << ``"Yes"` `<< endl;` `                ``return` `true``;` `            ``}` `            ``reverse(X.begin() + i, X.begin() + j + 1);` `        ``}` `    ``}` `    ``cout << ``"No"` `<< endl;` `    ``return` `false``;` `}`     `// Driver Code` `int` `main()` `{` `    ``string X = ``"adcbef"``, Y = ``"abcdef"``;`   `    ``// Function Call` `    ``checkString(X, Y);`   `    ``return` `0;` `}`

Output

```Yes
```

Time Complexity: O(N^2)

Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to check if the strings` `// can be made equal or not by` `// reversing a substring of X` `bool` `checkString(string X, string Y)` `{` `    ``// Store the first index from` `    ``// the left which contains unequal` `    ``// characters in both the strings` `    ``int` `L = -1;`   `    ``// Store the first element from` `    ``// the right which contains unequal` `    ``// characters in both the strings` `    ``int` `R = -1;`   `    ``// Checks for the first index from` `    ``// left in which characters in both` `    ``// the strings are unequal` `    ``for` `(``int` `i = 0; i < X.length(); ++i) {`   `        ``if` `(X[i] != Y[i]) {`   `            ``// Store the current index` `            ``L = i;`   `            ``// Break out of the loop` `            ``break``;` `        ``}` `    ``}`   `    ``// Checks for the first index from` `    ``// right in which characters in both` `    ``// the strings are unequal` `    ``for` `(``int` `i = X.length() - 1; i > 0; --i) {` `        ``if` `(X[i] != Y[i]) {`   `            ``// Store the current index` `            ``R = i;`   `            ``// Break out of the loop` `            ``break``;` `        ``}` `    ``}`   `    ``// Reverse the substring X[L, R]` `    ``reverse(X.begin() + L,` `            ``X.begin() + R + 1);`   `    ``// If X and Y are equal` `    ``if` `(X == Y) {` `        ``cout << ``"Yes"``;` `    ``}`   `    ``// Otherwise` `    ``else` `{` `        ``cout << ``"No"``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``string X = ``"adcbef"``, Y = ``"abcdef"``;`   `    ``// Function Call` `    ``checkString(X, Y);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to check if the Strings` `// can be made equal or not by` `// reversing a subString of X` `static` `void` `checkString(String X, String Y)` `{` `    ``// Store the first index from` `    ``// the left which contains unequal` `    ``// characters in both the Strings` `    ``int` `L = -``1``;`   `    ``// Store the first element from` `    ``// the right which contains unequal` `    ``// characters in both the Strings` `    ``int` `R = -``1``;`   `    ``// Checks for the first index from` `    ``// left in which characters in both` `    ``// the Strings are unequal` `    ``for` `(``int` `i = ``0``; i < X.length(); ++i) {`   `        ``if` `(X.charAt(i) != Y.charAt(i)) {`   `            ``// Store the current index` `            ``L = i;`   `            ``// Break out of the loop` `            ``break``;` `        ``}` `    ``}`   `    ``// Checks for the first index from` `    ``// right in which characters in both` `    ``// the Strings are unequal` `    ``for` `(``int` `i = X.length() - ``1``; i > ``0``; --i) {` `        ``if` `(X.charAt(i) != Y.charAt(i)) {`   `            ``// Store the current index` `            ``R = i;`   `            ``// Break out of the loop` `            ``break``;` `        ``}` `    ``}`   `    ``// Reverse the subString X[L, R]` `    ``X = X.substring(``0``, L) + ` `      ``reverse(X.substring(L, R + ``1``)) + ` `      ``X.substring(R + ``1``);`   `    ``// If X and Y are equal` `    ``if` `(X.equals(Y)) {` `        ``System.out.print(``"Yes"``);` `    ``}`   `    ``// Otherwise` `    ``else` `{` `        ``System.out.print(``"No"``);` `    ``}` `}` `static` `String reverse(String input) {` `    ``char``[] a = input.toCharArray();` `    ``int` `l, r = a.length - ``1``;` `    ``for` `(l = ``0``; l < r; l++, r--) {` `        ``char` `temp = a[l];` `        ``a[l] = a[r];` `        ``a[r] = temp;` `    ``}` `    ``return` `String.valueOf(a);` `}` `  `  `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``String X = ``"adcbef"``, Y = ``"abcdef"``;`   `    ``// Function Call` `    ``checkString(X, Y);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the above approach`   `# Function to check if the strings` `# can be made equal or not by` `# reversing a substring of X` `def` `checkString(X, Y):`   `    ``# Store the first index from` `    ``# the left which contains unequal` `    ``# characters in both the strings` `    ``L ``=` `-``1`   `    ``# Store the first element from` `    ``# the right which contains unequal` `    ``# characters in both the strings` `    ``R ``=` `-``1`   `    ``# Checks for the first index from` `    ``# left in which characters in both` `    ``# the strings are unequal` `    ``for` `i ``in` `range``(``len``(X)):` `        ``if` `(X[i] !``=` `Y[i]):`   `            ``# Store the current index` `            ``L ``=` `i`   `            ``# Break out of the loop` `            ``break`   `    ``# Checks for the first index from` `    ``# right in which characters in both` `    ``# the strings are unequal` `    ``for` `i ``in` `range``(``len``(X) ``-` `1``, ``0``, ``-``1``):` `        ``if` `(X[i] !``=` `Y[i]):` `            `  `            ``# Store the current index` `            ``R ``=` `i`   `            ``# Break out of the loop` `            ``break`   `    ``X ``=` `list``(X)` `    `  `    ``X ``=` `X[:L] ``+` `X[R  : L ``-` `1` `: ``-``1` `] ``+` `X[R ``+` `1``:]` `    `  `    ``# If X and Y are equal` `    ``if` `(X ``=``=` `list``(Y)):` `        ``print``(``"Yes"``)`   `    ``# Otherwise` `    ``else``:` `        ``print``(``"No"``)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``X ``=` `"adcbef"` `    ``Y ``=` `"abcdef"`   `    ``# Function Call` `    ``checkString(X, Y)` `    `  `# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to check if the Strings` `// can be made equal or not by` `// reversing a subString of X` `static` `void` `checkString(String X, String Y)` `{` `    `  `    ``// Store the first index from` `    ``// the left which contains unequal` `    ``// characters in both the Strings` `    ``int` `L = -1;`   `    ``// Store the first element from` `    ``// the right which contains unequal` `    ``// characters in both the Strings` `    ``int` `R = -1;`   `    ``// Checks for the first index from` `    ``// left in which characters in both` `    ``// the Strings are unequal` `    ``for``(``int` `i = 0; i < X.Length; ++i) ` `    ``{` `        ``if` `(X[i] != Y[i])` `        ``{` `            `  `            ``// Store the current index` `            ``L = i;`   `            ``// Break out of the loop` `            ``break``;` `        ``}` `    ``}`   `    ``// Checks for the first index from` `    ``// right in which characters in both` `    ``// the Strings are unequal` `    ``for``(``int` `i = X.Length - 1; i > 0; --i)` `    ``{` `        ``if` `(X[i] != Y[i])` `        ``{` `            `  `            ``// Store the current index` `            ``R = i;`   `            ``// Break out of the loop` `            ``break``;` `        ``}` `    ``}`   `    ``// Reverse the subString X[L, R]` `    ``X = X.Substring(0, L) + ` `        ``reverse(X.Substring(L, R + 1 - L)) + ` `        ``X.Substring(R + 1);`   `    ``// If X and Y are equal` `    ``if` `(X.Equals(Y)) ` `    ``{` `        ``Console.Write(``"Yes"``);` `    ``}`   `    ``// Otherwise` `    ``else` `    ``{` `        ``Console.Write(``"No"``);` `    ``}` `}`   `static` `String reverse(String input) ` `{` `    ``char``[] a = input.ToCharArray();` `    ``int` `l, r = a.Length - 1;` `    `  `    ``for``(l = 0; l < r; l++, r--) ` `    ``{` `        ``char` `temp = a[l];` `        ``a[l] = a[r];` `        ``a[r] = temp;` `    ``}` `    ``return` `String.Join(``""``,a);` `}` `  `  `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``String X = ``"adcbef"``, Y = ``"abcdef"``;`   `    ``// Function Call` `    ``checkString(X, Y);` `}` `}`   `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output

`Yes`

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

My Personal Notes arrow_drop_up
Related Articles