Check if a given string can be converted to another by given possible swaps

Given two strings str1 and str2, the task is to check if a string str1 can be converted to string str2 by performing the following operations any number of times:

• Swap any two characters of str1.
• Swap all the occurrences of a character of str1 to all occurrences of any other distinct character of str1.

Examples:

Input: str1 = “xyyzzlll”, str2 = “yllzzxxx” 
Output: True 
Explanation:
Swap all occurrences of str1[0] and str1[1] modifies str1 to “yxxzzlll” 
Swap all occurrences of str1[1] and str1[5] modifies str1 to “yllzzxxx” 
Since str1 and str2 are equal, therefore, the required output is True.

Input: str1 = “xyyzzavl”, str2 = “yllzzvac” 
Output: False 

Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• Initialize two arrays, say hash1[256] and hash2[256] to store the frequency of each distinct element of str1 and str2 respectively.
• Initialize two sets, say st1 and st2 to store the distinct characters of str1 and str2.
• Traverse the string and store the frequency of each distinct character of str1 and str2.
• Sort hash1[] and hash2[] array.
• If st1 and st2 are not equal then print false.
• Traverse hash1[] and hash2[] array using variable i and check if the value of (hash1[i] != hash2[i]) is true or not. If found to be true then print False.
• Otherwise, print True.

Below is the implementation of the above approach:

C++

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

bool checkStr1CanConStr2(string& str1,
                         string& str2)
{
    // Stores length of str1
    int N = str1.length();

    // Stores length of str2
    int M = str2.length();

    // Stores distinct characters
    // of str1
    set<int> st1;

    // Stores distinct characters
    // of str2
    set<int> st2;

    // Stores frequency of
    // each character of str1
    int hash1[256] = { 0 };

    // Traverse the string str1
    for (int i = 0; i < N; i++) {

        // Update frequency
        // of str1[i]
        hash1[str1[i]]++;
    }

    // Traverse the string str1
    for (int i = 0; i < N; i++) {

        // Insert str1[i]
        // into st1
        st1.insert(str1[i]);
    }

    // Traverse the string str2
    for (int i = 0; i < M; i++) {

        // Insert str1[i]
        // into st1
        st2.insert(str2[i]);
    }

    // If distinct characters in
    // str1 and str2 are not same
    if (st1 != st2) {
        return false;
    }

    // Stores frequency of
    // each character of str2
    int hash2[256] = { 0 };

    // Traverse the string str2
    for (int i = 0; i < M; i++) {

        // Update frequency
        // of str2[i]
        hash2[str2[i]]++;
    }

    // Sort hash1[] array
    sort(hash1, hash1 + 256);

    // Sort hash2[] array
    sort(hash2, hash2 + 256);

    // Traverse hash1[] and hash2[]
    for (int i = 0; i < 256; i++) {

        // If hash1[i] not
        // equal to hash2[i]
        if (hash1[i] != hash2[i]) {
            return false;
        }
    }
    return true;
}

// Driver Code
int main()
{
    string str1 = "xyyzzlll";
    string str2 = "yllzzxxx";
    if (checkStr1CanConStr2(str1, str2)) {
        cout << "True";
    }
    else {
        cout << "False";
    }
}

Java

// Java program to implement
// the above approach
import java.util.*;

class GFG{

static boolean checkStr1CanConStr2(String str1,
                         String str2)
{
    // Stores length of str1
    int N = str1.length();

    // Stores length of str2
    int M = str2.length();

    // Stores distinct characters
    // of str1
    HashSet<Integer> st1 = new HashSet<>();

    // Stores distinct characters
    // of str2
    HashSet<Integer> st2 =  new  HashSet<>();

    // Stores frequency of
    // each character of str1
    int hash1[] = new int[256];

    // Traverse the String str1
    for (int i = 0; i < N; i++)
    {

        // Update frequency
        // of str1[i]
        hash1[str1.charAt(i)]++;
    }

    // Traverse the String str1
    for (int i = 0; i < N; i++)
    {

        // Insert str1[i]
        // into st1
        st1.add((int)str1.charAt(i));
    }

    // Traverse the String str2
    for (int i = 0; i < M; i++)
    {

        // Insert str1[i]
        // into st1
        st2.add((int)str2.charAt(i));
    }

    // If distinct characters in
    // str1 and str2 are not same
    if (!st1.equals(st2))
    {
        return false;
    }

    // Stores frequency of
    // each character of str2
    int hash2[] = new int[256];

    // Traverse the String str2
    for (int i = 0; i < M; i++)
    {

        // Update frequency
        // of str2[i]
        hash2[str2.charAt(i)]++;
    }

    // Sort hash1[] array
    Arrays.sort(hash1);

    // Sort hash2[] array
    Arrays.sort(hash2);

    // Traverse hash1[] and hash2[]
    for (int i = 0; i < 256; i++)
    {

        // If hash1[i] not
        // equal to hash2[i]
        if (hash1[i] != hash2[i])
        {
            return false;
        }
    }
    return true;
}

// Driver Code
public static void main(String[] args)
{
    String str1 = "xyyzzlll";
    String str2 = "yllzzxxx";
    if (checkStr1CanConStr2(str1, str2))
    {
        System.out.print("True");
    }
    else
    {
        System.out.print("False");
    }
}
}

// This code is contributed by 29AjayKumar

Python3

# Python3 program to implement
# the above approach
def checkStr1CanConStr2(str1, str2):

    # Stores length of str1
    N = len(str1)

    # Stores length of str2
    M = len(str2)

    # Stores distinct characters
    # of str1
    st1 = set([])

    # Stores distinct characters
    # of str2
    st2 = set([])

    # Stores frequency of
    # each character of str1
    hash1 = [0] * 256

    # Traverse the string str1
    for i in range(N):

        # Update frequency
        # of str1[i]
        hash1[ord(str1[i])] += 1

    # Traverse the string str1
    for i in range(N):

        # Insert str1[i]
        # into st1
        st1.add(str1[i])

    # Traverse the string str2
    for i in range(M):

        # Insert str1[i]
        # into st1
        st2.add(str2[i])

    # If distinct characters in
    # str1 and str2 are not same
    if (st1 != st2):
        return False

    # Stores frequency of
    # each character of str2
    hash2 = [0] * 256

    # Traverse the string str2
    for i in range(M):

        # Update frequency
        # of str2[i]
        hash2[ord(str2[i])] += 1

    # Sort hash1[] array
    hash1.sort()

    # Sort hash2[] array
    hash2.sort()

    # Traverse hash1[] and hash2[]
    for i in range(256):

        # If hash1[i] not
        # equal to hash2[i]
        if (hash1[i] != hash2[i]):
            return False

    return True

# Driver Code
if __name__ == "__main__":

    str1 = "xyyzzlll"
    str2 = "yllzzxxx"

    if (checkStr1CanConStr2(str1, str2)):
        print("True")
    else:
        print("False")

# This code is contributed by chitranayal

C#

// C# program to implement
// the above approach
using System;
using System.Collections.Generic;

class GFG{

static bool checkStr1CanConStr2(String str1,
                         String str2)
{
    // Stores length of str1
    int N = str1.Length;

    // Stores length of str2
    int M = str2.Length;

    // Stores distinct characters
    // of str1
    HashSet<int> st1 = new HashSet<int>();

    // Stores distinct characters
    // of str2
    HashSet<int> st2 =  new  HashSet<int>();

    // Stores frequency of
    // each character of str1
    int []hash1 = new int[256];

    // Traverse the String str1
    for (int i = 0; i < N; i++)
    {

        // Update frequency
        // of str1[i]
        hash1[str1[i]]++;
    }

    // Traverse the String str1
    for (int i = 0; i < N; i++)
    {

        // Insert str1[i]
        // into st1
        st1.Add(str1[i]);
    }

    // Traverse the String str2
    for (int i = 0; i < M; i++)
    {

        // Insert str1[i]
        // into st1
        st2.Add(str2[i]);
    }

    // If distinct characters in
    // str1 and str2 are not same
    if (st1.Equals(st2))
    {
        return false;
    }

    // Stores frequency of
    // each character of str2
    int []hash2 = new int[256];

    // Traverse the String str2
    for (int i = 0; i < M; i++)
    {

        // Update frequency
        // of str2[i]
        hash2[str2[i]]++;
    }

    // Sort hash1[] array
    Array.Sort(hash1);

    // Sort hash2[] array
    Array.Sort(hash2);

    // Traverse hash1[] and hash2[]
    for (int i = 0; i < 256; i++)
    {

        // If hash1[i] not
        // equal to hash2[i]
        if (hash1[i] != hash2[i])
        {
            return false;
        }
    }
    return true;
}

// Driver Code
public static void Main(String[] args)
{
    String str1 = "xyyzzlll";
    String str2 = "yllzzxxx";
    if (checkStr1CanConStr2(str1, str2))
    {
        Console.Write("True");
    }
    else
    {
        Console.Write("False");
    }
}
}

 // This code is contributed by 29AjayKumar

Javascript

<script>

// Javascript program to implement
// the above approach

function checkStr1CanConStr2(str1, str2)
{
    // Stores length of str1
    var N = str1.length;

    // Stores length of str2
    var M = str2.length;

    // Stores distinct characters
    // of str1
    var st1 = new Set();

    // Stores distinct characters
    // of str2
    var st2 = new Set();

    // Stores frequency of
    // each character of str1
    var hash1 = Array(256).fill(0);

    // Traverse the string str1
    for (var i = 0; i < N; i++) {

        // Update frequency
        // of str1[i]
        hash1[str1[i].charCodeAt(0)]++;
    }

    // Traverse the string str1
    for (var i = 0; i < N; i++) {

        // Insert str1[i]
        // into st1
        st1.add(str1[i]);
    }

    // Traverse the string str2
    for (var i = 0; i < M; i++) {

        // Insert str1[i]
        // into st1
        st2.add(str2[i]);
    }

    // If distinct characters in
    // str1 and str2 are not same
    if (st1.size != st2.size) {
        return false;
    }

    // Stores frequency of
    // each character of str2
    var hash2 = Array(256).fill(0);

    // Traverse the string str2
    for (var i = 0; i < M; i++) {

        // Update frequency
        // of str2[i]
        hash2[str2[i].charCodeAt(0)]++;
    }

    // Sort hash1[] array
    hash1.sort((a,b)=>a-b);
    hash2.sort((a,b)=>a-b);

    // Traverse hash1[] and hash2[]
    for (var i = 0; i < 256; i++) {

        // If hash1[i] not
        // equal to hash2[i]
        if (hash1[i] != hash2[i]) {

            return false;
        }
    }
    return true;
}

// Driver Code
var str1 = "xyyzzlll";
var str2 = "yllzzxxx";
if (checkStr1CanConStr2(str1, str2)) {
    document.write( "True");
}
else {
    document.write( "False");
}


</script>

Output:

True

Time Complexity: O(N + M + 256)
Auxiliary Space: O(256)