# Check if two arrays can be made equal by reversing any subarray once

Given two arrays A[] and B[] of equal size N, the task is to check whether A[] can be made equal to B[] by reversing any sub-array of A only once.
Examples:

Input: A[] = {1, 3, 2, 4}
B[] = {1, 2, 3, 4}
Output: Yes
Explanation:
The sub-array {3, 2} can be reversed to {2, 3} which makes A equal to B

Input: A[] = {1, 4, 2, 3}
B[] = {1, 2, 3, 4}
Output: No
Explanation:
There is no sub-array of A which when reversed makes A equal to B

Naive Approach: Check for all sub-arrays of A[] and compare the two arrays after reversing the sub-array.
Time complexity: O(N2).

Efficient Approach:

• First find the starting and the ending index of the sub-array not equal in A and B
• Then by reversing the required sub-array we can check whether A can be made equal to B or not.
• The starting index is the first index in the arrays for which A[i] != B[i] and the ending index is the last index in arrays for which A[i] != B[i]

Below is the implementation of the above approach.

## C++

 `// C++ implementation to ` `// check whether two arrays ` `// can be made equal by ` `// reversing a sub-array ` `// only once ` `#include ` `using` `namespace` `std; ` ` `  `// Function to check whether two arrays ` `// can be made equal by reversing ` `// a sub-array only once ` `void` `checkArray(``int` `A[], ``int` `B[], ``int` `N) ` `{ ` `    ``// Integer variable for ` `    ``// storing the required ` `    ``// starting and ending ` `    ``// indices in the array ` `    ``int` `start = 0; ` `    ``int` `end = N - 1; ` ` `  `    ``// Finding the smallest index ` `    ``// for which A[i] != B[i] ` `    ``// i.e the starting index ` `    ``// of the unequal sub-array ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``if` `(A[i] != B[i]) { ` `            ``start = i; ` `            ``break``; ` `        ``} ` `    ``} ` `    ``// Finding the largest index ` `    ``// for which A[i] != B[i] ` `    ``// i.e the ending index ` `    ``// of the unequal sub-array ` `    ``for` `(``int` `i = N - 1; i >= 0; i--) { ` `        ``if` `(A[i] != B[i]) { ` `            ``end = i; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Reversing the sub-array ` `    ``// A[start], A[start+1] .. A[end] ` `    ``reverse(A + start, A + end + 1); ` ` `  `    ``// Checking whether on reversing ` `    ``// the sub-array A[start]...A[end] ` `    ``// makes the arrays equal ` ` `  `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``if` `(A[i] != B[i]) { ` `            ``// If any element of the ` `            ``// two arrays is unequal ` `            ``// print No and return ` `            ``cout << ``"No"` `<< endl; ` `            ``return``; ` `        ``} ` `    ``} ` `    ``// Print Yes if arrays are ` `    ``// equal after reversing ` `    ``// the sub-array ` `    ``cout << ``"Yes"` `<< endl; ` `} ` `// Driver code ` `int` `main() ` `{ ` `    ``int` `A[] = { 1, 3, 2, 4 }; ` `    ``int` `B[] = { 1, 2, 3, 4 }; ` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A); ` `    ``checkArray(A, B, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation to ` `// check whether two arrays ` `// can be made equal by ` `// reversing a sub-array ` `// only once ` `import` `java.util.*;  ` `class` `GFG{ ` `  `  `// Function to check whether two arrays ` `// can be made equal by reversing ` `// a sub-array only once ` `static` `void` `checkArray(``int` `A[], ``int` `B[], ``int` `N) ` `{ ` `    ``// Integer variable for ` `    ``// storing the required ` `    ``// starting and ending ` `    ``// indices in the array ` `    ``int` `start = ``0``; ` `    ``int` `end = N - ``1``; ` `  `  `    ``// Finding the smallest index ` `    ``// for which A[i] != B[i] ` `    ``// i.e the starting index ` `    ``// of the unequal sub-array ` `    ``for` `(``int` `i = ``0``; i < N; i++)  ` `    ``{ ` `        ``if` `(A[i] != B[i])  ` `        ``{ ` `            ``start = i; ` `            ``break``; ` `        ``} ` `    ``} ` `    ``// Finding the largest index ` `    ``// for which A[i] != B[i] ` `    ``// i.e the ending index ` `    ``// of the unequal sub-array ` `    ``for` `(``int` `i = N - ``1``; i >= ``0``; i--) ` `    ``{ ` `        ``if` `(A[i] != B[i]) ` `        ``{ ` `            ``end = i; ` `            ``break``; ` `        ``} ` `    ``} ` `  `  `    ``// Reversing the sub-array ` `    ``// A[start], A[start+1] .. A[end] ` `    ``Collections.reverse(Arrays.asList(A));  ` `  `  `    ``// Checking whether on reversing ` `    ``// the sub-array A[start]...A[end] ` `    ``// makes the arrays equal ` `    ``for` `(``int` `i = ``0``; i < N; i++)  ` `    ``{ ` `        ``if` `(A[i] != B[i]) ` `        ``{ ` `            ``// If any element of the ` `            ``// two arrays is unequal ` `            ``// print No and return ` `            ``System.out.println(``"Yes"``); ` `            ``return``; ` `        ``} ` `    ``} ` `    ``// Print Yes if arrays are ` `    ``// equal after reversing ` `    ``// the sub-array ` `   ``System.out.println(``"Yes"``); ` `} ` `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `A[] = { ``1``, ``3``, ``2``, ``4` `}; ` `    ``int` `B[] = { ``1``, ``2``, ``3``, ``4` `}; ` `    ``int` `N = A.length; ` `    ``checkArray(A, B, N); ` `} ` `} ` ` `  `// This Code is contributed by rock_cool`

## Python3

 `# Python3 implementation to ` `# check whether two arrays ` `# can be made equal by ` `# reversing a sub-array ` `# only once ` ` `  `# Function to check whether two arrays ` `# can be made equal by reversing ` `# a sub-array only once ` `def` `checkArray(A, B, N): ` `     `  `    ``# Integer variable for ` `    ``# storing the required ` `    ``# starting and ending ` `    ``# indices in the array ` `    ``start ``=` `0` `    ``end ``=` `N ``-` `1` ` `  `    ``# Finding the smallest index ` `    ``# for which A[i] != B[i] ` `    ``# i.e the starting index ` `    ``# of the unequal sub-array ` `    ``for` `i ``in` `range``(N): ` `        ``if` `(A[i] !``=` `B[i]): ` `            ``start ``=` `i ` `            ``break` `             `  `    ``# Finding the largest index ` `    ``# for which A[i] != B[i] ` `    ``# i.e the ending index ` `    ``# of the unequal sub-array ` `    ``for` `i ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``): ` `        ``if` `(A[i] !``=` `B[i]): ` `            ``end ``=` `i ` `            ``break` ` `  `    ``# Reversing the sub-array ` `    ``# A[start], A[start+1] .. A[end] ` `    ``A[start:end ``+` `1``] ``=` `reversed``(A[start:end ``+` `1``]) ` `     `  `    ``# Checking whether on reversing ` `    ``# the sub-array A[start]...A[end] ` `    ``# makes the arrays equal ` `    ``for` `i ``in` `range``(N): ` `        ``if` `(A[i] !``=` `B[i]): ` `             `  `            ``# If any element of the ` `            ``# two arrays is unequal ` `            ``# print No and return ` `            ``print``(``"No"``) ` `            ``return` `             `  `    ``# Print Yes if arrays are ` `    ``# equal after reversing ` `    ``# the sub-array ` `    ``print``(``"Yes"``) ` `     `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``A ``=` `[ ``1``, ``3``, ``2``, ``4` `] ` `    ``B ``=` `[ ``1``, ``2``, ``3``, ``4` `] ` `    ``N ``=` `len``(A) ` `     `  `    ``checkArray(A, B, N) ` `     `  `# This code is contributed by mohit kumar 29 `

## C#

 `// C# implementation to ` `// check whether two arrays ` `// can be made equal by ` `// reversing a sub-array ` `// only once ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to check whether two arrays ` `// can be made equal by reversing ` `// a sub-array only once ` `static` `void` `checkArray(``int` `[]A, ``int` `[]B, ``int` `N) ` `{ ` `     `  `    ``// Integer variable for ` `    ``// storing the required ` `    ``// starting and ending ` `    ``// indices in the array ` `    ``int` `start = 0; ` `    ``int` `end = N - 1; ` ` `  `    ``// Finding the smallest index ` `    ``// for which A[i] != B[i] ` `    ``// i.e the starting index ` `    ``// of the unequal sub-array ` `    ``for``(``int` `i = 0; i < N; i++)  ` `    ``{ ` `        ``if` `(A[i] != B[i])  ` `        ``{ ` `            ``start = i; ` `            ``break``; ` `        ``} ` `    ``} ` `     `  `    ``// Finding the largest index ` `    ``// for which A[i] != B[i] ` `    ``// i.e the ending index ` `    ``// of the unequal sub-array ` `    ``for``(``int` `i = N - 1; i >= 0; i--) ` `    ``{ ` `        ``if` `(A[i] != B[i]) ` `        ``{ ` `            ``end = i; ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// Reversing the sub-array ` `    ``// A[start], A[start+1] .. A[end] ` `    ``Array.Reverse(A, start, end); ` ` `  ` `  `    ``// Checking whether on reversing ` `    ``// the sub-array A[start]...A[end] ` `    ``// makes the arrays equal ` `    ``for``(``int` `i = 0; i < N; i++)  ` `    ``{ ` `        ``if` `(A[i] != B[i]) ` `        ``{ ` `             `  `            ``// If any element of the ` `            ``// two arrays is unequal ` `            ``// print No and return ` `            ``Console.Write(``"Yes"``); ` `            ``return``; ` `        ``} ` `    ``} ` `     `  `    ``// Print Yes if arrays are ` `    ``// equal after reversing ` `    ``// the sub-array ` `    ``Console.Write(``"Yes"``); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(``string``[] args)  ` `{ ` `    ``int` `[]A = { 1, 3, 2, 4 }; ` `    ``int` `[]B = { 1, 2, 3, 4 }; ` `    ``int` `N = A.Length; ` `    ``checkArray(A, B, N); ` `} ` `} ` ` `  `// This code is contributed by rutvik_56 `

Output:

```Yes
```

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.