# Check if two array of string are equal by performing swapping operations

Given two arrays **arr[] **and** brr[]** of the same size containing strings of equal lengths. In one operation any two characters from any string in **brr[]** can be swapped with each other or swap any two strings in brr[]. The task is to find whether **brr[]** can be made equal to **arr[]** or not.

**Example:**

Input:arr[] = { “bcd”, “aac” }, brr[] = { “aca”, “dbc” }Output:trueExplanation:The following swapping operations are performed in brr[] to make arr[] equal to brr[].

swap ( brr[0][1], brr[0][2] ) –> brr[0] changes to “aac”, which is equal to arr[1].

swap ( brr[1][0], brr[1][1] ) –> brr[1] changes to “bdc”.

swap (brr[1][1], brr[1][2]) –> brr[1] changes to “bcd”, which is equal to arr[0].

swapping ( brr[0], brr[1] ) which changes brr[] to { “bcd”, “aac” } which is equal to arr[].Therefore, brr[] can be made equal to arr[] by doing above operations.

Input: arr[]= { “ab”, “c” }, brr = { “ac”, “b” }Output:false

**Approach:** The given problem can be solved by using the Greedy approach. Two strings can be made equal by swapping only if the frequency of each character in one string is equal to the other string. If both strings are sorted then all the characters are arranged and then just seeing whether the two sorted strings are equal or not will the answer. Follow the steps below to solve the given problem.

- Sort each string in
**arr[]**as well as in**brr[]**. - Sort
**arr[]**and**brr[]**. - Iterate in
**arr[]**with variable**i**and for each**i**- Check whether
**arr[i] == brr[i]**.- if true, continue comparing the remaining strings.
- if false, it means there is at least one string that is not in
**brr[]**. Therefore return false.

- Check whether
- After checking, return true as the final answer.

Below is the implementation of the above approach:

## C++14

`// C++ program for above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to check whether brr[] can be made` `// equal to arr[] by doing swapping operations` `bool` `checkEqualArrays(vector<string> arr,` ` ` `vector<string> brr,` ` ` `int` `N)` `{` ` ` `// siz variable to store siz of string` ` ` `int` `siz = arr[0].size();` ` ` `// iterate till N to sort strings` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// sort each string in arr[]` ` ` `sort(arr[i].begin(), arr[i].end());` ` ` `// sort each string in brr[]` ` ` `sort(brr[i].begin(), brr[i].end());` ` ` `}` ` ` `// Sort both the vectors so that all` ` ` `// the comparable strings will be arranged` ` ` `sort(arr.begin(), arr.end());` ` ` `sort(brr.begin(), brr.end());` ` ` `// iterate till N` ` ` `// to compare string in arr[]` ` ` `// and brr[]` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Compare each string` ` ` `if` `(arr[i] != brr[i]) {` ` ` `// Return false becaues` ` ` `// if atleast one` ` ` `// string is not equal` ` ` `// then brr[] cannot` ` ` `// be converted to arr[]` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` `// All the strings` ` ` `// are compared so at last` ` ` `// return true.` ` ` `return` `true` `;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `N = 2;` ` ` `vector<string> arr = { ` `"bcd"` `, ` `"aac"` `};` ` ` `vector<string> brr = { ` `"aca"` `, ` `"dbc"` `};` ` ` `// Store the answer in variable` ` ` `bool` `ans = checkEqualArrays(arr, brr, N);` ` ` `if` `(ans)` ` ` `cout << ` `"true"` `;` ` ` `else` ` ` `cout << ` `"false"` `;` ` ` `return` `0;` `}` |

## Python3

`# Python3 program for above approach` `# Function to check whether brr[] can be made` `# equal to arr[] by doing swapping operations` `def` `checkEqualArrays(arr,brr, N) :` ` ` `# siz variable to store size of string` ` ` `siz ` `=` `len` `(arr[` `0` `]);` ` ` `# iterate till N to sort strings` ` ` `for` `i ` `in` `range` `(N) :` ` ` ` ` `# sort each string in arr[]` ` ` `temp1 ` `=` `list` `(arr[i]);` ` ` `temp1.sort();` ` ` `arr[i] ` `=` `"".join(temp1)` ` ` `# sort each string in brr[]` ` ` `temp2 ` `=` `list` `(brr[i]);` ` ` `temp2.sort();` ` ` `brr[i] ` `=` `"".join(temp2);` ` ` `# Sort both the vectors so that all` ` ` `# the comparable strings will be arranged` ` ` `arr.sort()` ` ` `brr.sort()` ` ` `# iterate till N` ` ` `# to compare string in arr[]` ` ` `# and brr[]` ` ` `for` `i ` `in` `range` `(N) :` ` ` `# Compare each string` ` ` `if` `(arr[i] !` `=` `brr[i]) :` ` ` `# Return false becaues` ` ` `# if atleast one` ` ` `# string is not equal` ` ` `# then brr[] cannot` ` ` `# be converted to arr[]` ` ` `return` `False` `;` ` ` `# All the strings` ` ` `# are compared so at last` ` ` `# return true.` ` ` `return` `True` `;` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `2` `;` ` ` `arr ` `=` `[ ` `"bcd"` `, ` `"aac"` `];` ` ` `brr ` `=` `[ ` `"aca"` `, ` `"dbc"` `];` ` ` `# Store the answer in variable` ` ` `ans ` `=` `checkEqualArrays(arr, brr, N);` ` ` `if` `(ans) :` ` ` `print` `(` `"true"` `);` ` ` `else` `:` ` ` `print` `(` `"false"` `);` ` ` `# This code is contributed by AnkThon` |

## Javascript

`<script>` `// Javascript program for above approach` `// Function to check whether brr[] can be made` `// equal to arr[] by doing swapping operations` `function` `checkEqualArrays(arr, brr, N)` `{` ` ` `// siz variable to store siz of string` ` ` `let siz = arr[0].length;` ` ` `// iterate till N to sort strings` ` ` `for` `(let i = 0; i < N; i++)` ` ` `{` ` ` ` ` `// sort each string in arr[]` ` ` `arr[i] = arr[i].split(` `""` `).sort().join(` `""` `)` ` ` `// sort each string in brr[]` ` ` `brr[i] = brr[i].split(` `""` `).sort().join(` `""` `)` ` ` ` ` `}` ` ` `// Sort both the vectors so that all` ` ` `// the comparable strings will be arranged` ` ` `arr.sort()` ` ` `brr.sort()` ` ` `// iterate till N` ` ` `// to compare string in arr[]` ` ` `// and brr[]` ` ` `for` `(let i = 0; i < N; i++) {` ` ` `// Compare each string` ` ` `if` `(arr[i] != brr[i]) {` ` ` `// Return false becaues` ` ` `// if atleast one` ` ` `// string is not equal` ` ` `// then brr[] cannot` ` ` `// be converted to arr[]` ` ` `return` `false` `;` ` ` `}` ` ` `}` ` ` `// All the strings` ` ` `// are compared so at last` ` ` `// return true.` ` ` `return` `true` `;` `}` `// Driver code` ` ` `let N = 2;` ` ` `let arr = [ ` `"bcd"` `, ` `"aac"` `];` ` ` `let brr = [ ` `"aca"` `, ` `"dbc"` `];` ` ` `// Store the answer in variable` ` ` `let ans = checkEqualArrays(arr, brr, N);` ` ` `if` `(ans)` ` ` `document.write(` `"true"` `);` ` ` `else` ` ` `document.write(` `"false"` `);` ` ` ` ` `// This code is contributed by saurabh_jaiswal.` `</script>` |

**Output**

true

**Time Complexity: **O(2* (N * logN) + 2 * (N * logM) ), where N is the size of array and M is the size of each string. **Auxiliary Space: **O(1)

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.