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: true
Explanation: 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.
• After checking, return true as the final answer.

Below is the implementation of the above approach:

// 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)
{

    // size variable to store size of string
    int size = 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 because
            // 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;
}

import java.util.*;

class Main {
    // Function to check whether brr[] can be made
    // equal to arr[] by doing swapping operations
    static boolean checkEqualArrays(String[] arr,
                                    String[] brr,
                                    int N) {

        // size variable to store size of string
        int size = arr[0].length();

        // iterate till N to sort strings
        for (int i = 0; i < N; i++) {
            // sort each string in arr[]
            char[] charArr = arr[i].toCharArray();
            Arrays.sort(charArr);
            arr[i] = new String(charArr);

            // sort each string in brr[]
            charArr = brr[i].toCharArray();
            Arrays.sort(charArr);
            brr[i] = new String(charArr);
        }

        // Sort both the arrays so that all
        // the comparable strings will be arranged
        Arrays.sort(arr);
        Arrays.sort(brr);

        // iterate till N
        // to compare string in arr[]
        // and brr[]
        for (int i = 0; i < N;i++){
        
         // Compare each string
        if (!arr[i].equals(brr[i])) {

            // Return false because
            // 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;
    }
   public static void main(String[] args) {
        int N = 2;
        String[] arr = { "bcd", "aac" };
        String[] brr = { "aca", "dbc" };

        // Store the answer in variable
        boolean ans = checkEqualArrays(arr, brr, N);

        if (ans)
            System.out.println("true");
        else
            System.out.println("false");
    }
}

# 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) :

    # size variable to store size of string
    size = 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 because
            # 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

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
  // Function to check whether brr[] can be made
  // equal to arr[] by doing swapping operations
  static bool CheckEqualArrays(List<string> arr,
                               List<string> brr,
                               int N)
  {
    // size variable to store size of string
    int size = arr[0].Length;

    // iterate till N to sort strings
    for (int i = 0; i < N; i++)
    {
      // sort each string in arr[]
      arr[i] = new string(arr[i].OrderBy(c => c).ToArray());

      // sort each string in brr[]
      brr[i] = new string(brr[i].OrderBy(c => c).ToArray());
    }

    // Sort both the lists so that all
    // the comparable strings will be arranged
    arr.Sort();
    brr.Sort();

    // 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 because
        // 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
  static void Main(string[] args)
  {
    int N = 2;
    List<string> arr = new List<string> { "bcd", "aac" };
    List<string> brr = new List<string> { "aca", "dbc" };

    // Store the answer in variable
    bool ans = CheckEqualArrays(arr, brr, N);

    if (ans)
      Console.WriteLine("true");
    else
      Console.WriteLine("false");
  }
}

<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)
{

    // size variable to store size of string
    let size = 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 because
            // 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>

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)