# 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

**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 <bits/stdc++.h> ` `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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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
[tabbyending]

**Output:**

Yes

## Recommended Posts:

- Remove all occurrences of a character in a string
- Count occurrences of a character in a repeated string
- Number of permutations of a string in which all the occurrences of a given character occurs together
- Print the string by ignoring alternate occurrences of any character
- Replace every character of string by character whose ASCII value is K times more than it
- Find a string such that every character is lexicographically greater than its immediate next character
- Replace every character of a string by a different character
- Check if all occurrences of a character appear together
- Check if frequency of character in one string is a factor or multiple of frequency of same character in other string
- Printing frequency of each character just after its consecutive occurrences
- Minimize ASCII values sum after removing all occurrences of one character
- Find the number of occurrences of a character upto preceding position
- Count substrings that starts with character X and ends with character Y
- Longest Common Prefix using Character by Character Matching
- Shortest distance to every other character from given character

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.