# Map every character of one string to another such that all occurrences are mapped to the same character

Given two string s1 and s2, the task is to check if characters of the first string can be mapped with the character of the second string such that if a character ch1 is mapped with some character ch2 then all the occurrences of ch1 will only be mapped with ch2 for both the strings.

Examples:

Input: s1 = “axx”, s2 = “cbc”
Output: Yes
‘a’ in s1 can be mapped to ‘b’ in s2
and ‘x’ in s1 can be mapped to ‘c’ in s2.

Input: s1 = “a”, s2 = “df”
Output: No

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: If the lengths of both the strings are unequal then the strings cannot be mapped else create two frequency arrays freq1[] and freq2[] which will store the frequencies of all the characters of the given strings s1 and s2 respectively. Now, for every non-zero value in freq1[] find an equal value in freq2[]. If all the non-zero values from freq1[] can be mapped to some value in freq2[] then the answer is possible else not.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `#define MAX 26 ` ` `  `// Function that returns true if the mapping is possible ` `bool` `canBeMapped(string s1, ``int` `l1, string s2, ``int` `l2) ` `{ ` ` `  `    ``// Both the strings are of un-equal lengths ` `    ``if` `(l1 != l2) ` `        ``return` `false``; ` ` `  `    ``// To store the frequencies of the ` `    ``// characters in both the string ` `    ``int` `freq1[MAX] = { 0 }; ` `    ``int` `freq2[MAX] = { 0 }; ` ` `  `    ``// Update frequencies of the characters ` `    ``for` `(``int` `i = 0; i < l1; i++) ` `        ``freq1[s1[i] - ``'a'``]++; ` `    ``for` `(``int` `i = 0; i < l2; i++) ` `        ``freq2[s2[i] - ``'a'``]++; ` ` `  `    ``// For every character of s1 ` `    ``for` `(``int` `i = 0; i < MAX; i++) { ` ` `  `        ``// If current character is ` `        ``// not present in s1 ` `        ``if` `(freq1[i] == 0) ` `            ``continue``; ` `        ``bool` `found = ``false``; ` ` `  `        ``// Find a character in s2 that has frequency ` `        ``// equal to the current character's ` `        ``// frequency in s1 ` `        ``for` `(``int` `j = 0; j < MAX; j++) { ` ` `  `            ``// If such character is found ` `            ``if` `(freq1[i] == freq2[j]) { ` ` `  `                ``// Set the frequnecy to -1 so that ` `                ``// it doesn't get picked again ` `                ``freq2[j] = -1; ` ` `  `                ``// Set found to true ` `                ``found = ``true``; ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// If there is no character in s2 ` `        ``// that could be mapped to the ` `        ``// current character in s1 ` `        ``if` `(!found) ` `            ``return` `false``; ` `    ``} ` ` `  `    ``return` `true``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string s1 = ``"axx"``; ` `    ``string s2 = ``"cbc"``; ` `    ``int` `l1 = s1.length(); ` `    ``int` `l2 = s2.length(); ` ` `  `    ``if` `(canBeMapped(s1, l1, s2, l2)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GFG ` `{ ` ` `  `    ``static` `int` `MAX = ``26``; ` ` `  `    ``// Function that returns true if the mapping is possible ` `    ``public` `static` `boolean` `canBeMapped(String s1, ``int` `l1,  ` `                                        ``String s2, ``int` `l2)  ` `    ``{ ` `         `  `        ``// Both the strings are of un-equal lengths ` `        ``if` `(l1 != l2) ` `            ``return` `false``; ` ` `  `        ``// To store the frequencies of the ` `        ``// characters in both the string ` `        ``int``[] freq1 = ``new` `int``[MAX]; ` `        ``int``[] freq2 = ``new` `int``[MAX]; ` ` `  `        ``// Update frequencies of the characters ` `        ``for` `(``int` `i = ``0``; i < l1; i++) ` `            ``freq1[s1.charAt(i) - ``'a'``]++; ` `        ``for` `(``int` `i = ``0``; i < l2; i++) ` `            ``freq2[s2.charAt(i) - ``'a'``]++; ` ` `  `        ``// For every character of s1 ` `        ``for` `(``int` `i = ``0``; i < MAX; i++) { ` ` `  `            ``// If current character is ` `            ``// not present in s1 ` `            ``if` `(freq1[i] == ``0``) ` `                ``continue``; ` `            ``boolean` `found = ``false``; ` ` `  `            ``// Find a character in s2 that has frequency ` `            ``// equal to the current character's ` `            ``// frequency in s1 ` `            ``for` `(``int` `j = ``0``; j < MAX; j++)  ` `            ``{ ` ` `  `                ``// If such character is found ` `                ``if` `(freq1[i] == freq2[j])  ` `                ``{ ` ` `  `                    ``// Set the frequnecy to -1 so that ` `                    ``// it doesn't get picked again ` `                    ``freq2[j] = -``1``; ` ` `  `                    ``// Set found to true ` `                    ``found = ``true``; ` `                    ``break``; ` `                ``} ` `            ``} ` ` `  `            ``// If there is no character in s2 ` `            ``// that could be mapped to the ` `            ``// current character in s1 ` `            ``if` `(!found) ` `                ``return` `false``; ` `        ``} ` ` `  `        ``return` `true``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``String s1 = ``"axx"``; ` `        ``String s2 = ``"cbc"``; ` `        ``int` `l1 = s1.length(); ` `        ``int` `l2 = s2.length(); ` ` `  `        ``if` `(canBeMapped(s1, l1, s2, l2)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` ` `  `    ``} ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Python3

 `# Python 3 implementation of the approach ` ` `  `MAX` `=` `26` ` `  `# Function that returns true if the mapping is possible ` `def` `canBeMapped(s1, l1, s2, l2): ` `    ``# Both the strings are of un-equal lengths ` `    ``if` `(l1 !``=` `l2): ` `        ``return` `False` ` `  `    ``# To store the frequencies of the ` `    ``# characters in both the string ` `    ``freq1 ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` `    ``freq2 ``=` `[``0` `for` `i ``in` `range``(``MAX``)] ` ` `  `    ``# Update frequencies of the characters ` `    ``for` `i ``in` `range``(l1): ` `        ``freq1[``ord``(s1[i]) ``-` `ord``(``'a'``)] ``+``=` `1` `    ``for` `i ``in` `range``(l2): ` `        ``freq2[``ord``(s2[i]) ``-` `ord``(``'a'``)] ``+``=` `1` ` `  `    ``# For every character of s1 ` `    ``for` `i ``in` `range``(``MAX``): ` `        ``# If current character is ` `        ``# not present in s1 ` `        ``if` `(freq1[i] ``=``=` `0``): ` `            ``continue` `        ``found ``=` `False` ` `  `        ``# Find a character in s2 that has frequency ` `        ``# equal to the current character's ` `        ``# frequency in s1 ` `        ``for` `j ``in` `range``(``MAX``): ` `            ``# If such character is found ` `            ``if` `(freq1[i] ``=``=` `freq2[j]): ` `                ``# Set the frequnecy to -1 so that ` `                ``# it doesn't get picked again ` `                ``freq2[j] ``=` `-``1` ` `  `                ``# Set found to true ` `                ``found ``=` `True` `                ``break` ` `  `        ``# If there is no character in s2 ` `        ``# that could be mapped to the ` `        ``# current character in s1 ` `        ``if` `(found``=``=``False``): ` `            ``return` `False` ` `  `    ``return` `True` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``s1 ``=` `"axx"` `    ``s2 ``=` `"cbc"` `    ``l1 ``=` `len``(s1) ` `    ``l2 ``=` `len``(s2) ` ` `  `    ``if` `(canBeMapped(s1, l1, s2, l2)): ` `        ``print``(``"Yes"``) ` `    ``else``: ` `        ``print``(``"No"``) ` `         `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of the approach  ` `using` `System; ` `     `  `class` `GFG ` `{ ` `    ``static` `int` `MAX = 26; ` ` `  `    ``// Function that returns true ` `    ``// if the mapping is possible ` `    ``public` `static` `Boolean canBeMapped(String s1, ``int` `l1,  ` `                                      ``String s2, ``int` `l2)  ` `    ``{ ` `         `  `        ``// Both the strings are of un-equal lengths ` `        ``if` `(l1 != l2) ` `            ``return` `false``; ` ` `  `        ``// To store the frequencies of the ` `        ``// characters in both the string ` `        ``int``[] freq1 = ``new` `int``[MAX]; ` `        ``int``[] freq2 = ``new` `int``[MAX]; ` ` `  `        ``// Update frequencies of the characters ` `        ``for` `(``int` `i = 0; i < l1; i++) ` `            ``freq1[s1[i] - ``'a'``]++; ` `        ``for` `(``int` `i = 0; i < l2; i++) ` `            ``freq2[s2[i] - ``'a'``]++; ` ` `  `        ``// For every character of s1 ` `        ``for` `(``int` `i = 0; i < MAX; i++) ` `        ``{ ` ` `  `            ``// If current character is ` `            ``// not present in s1 ` `            ``if` `(freq1[i] == 0) ` `                ``continue``; ` `            ``Boolean found = ``false``; ` ` `  `            ``// Find a character in s2 that has frequency ` `            ``// equal to the current character's ` `            ``// frequency in s1 ` `            ``for` `(``int` `j = 0; j < MAX; j++)  ` `            ``{ ` ` `  `                ``// If such character is found ` `                ``if` `(freq1[i] == freq2[j])  ` `                ``{ ` ` `  `                    ``// Set the frequnecy to -1 so that ` `                    ``// it doesn't get picked again ` `                    ``freq2[j] = -1; ` ` `  `                    ``// Set found to true ` `                    ``found = ``true``; ` `                    ``break``; ` `                ``} ` `            ``} ` ` `  `            ``// If there is no character in s2 ` `            ``// that could be mapped to the ` `            ``// current character in s1 ` `            ``if` `(!found) ` `                ``return` `false``; ` `        ``} ` `        ``return` `true``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``String s1 = ``"axx"``; ` `        ``String s2 = ``"cbc"``; ` `        ``int` `l1 = s1.Length; ` `        ``int` `l2 = s2.Length; ` ` `  `        ``if` `(canBeMapped(s1, l1, s2, l2)) ` `            ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by PrinciRaj1992  `

Output:

```Yes
```

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.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.