Given two strings return the value of least number of manipulations needed to ensure both strings have identical characters, i.e., both string become anagram of each other.

**Examples:**

Input : s1 = "aab" s2 = "aba" Output : 2 Explanation : string 1 contains 2 a's and 1 b, also string 2 contains same characters Input : s1 = "abc" s2 = "cdd" Output : 2 Explanation : string 1 contains 1 a, 1 b, 1 c while string 2 contains 1 c and 2 d's so there are 2 different characters

**Question Source :** Yatra.com Interview Experience | Set 7

The idea is to create a extra count array for both the strings separately and then count the difference in characters.

## C++

`// CPP program to count least number ` `// of manipulations to have two strings ` `// set of same characters ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `MAX_CHAR = 26; ` ` ` `// return the count of manipulations ` `// required ` `int` `leastCount(string s1, string s2, ` `int` `n) ` `{ ` ` ` `int` `count1[MAX_CHAR] = { 0 }; ` ` ` `int` `count2[MAX_CHAR] = { 0 }; ` ` ` ` ` `// count the number of different ` ` ` `// characters in both strings ` ` ` `for` `(` `int` `i = 0; i < n; i++) { ` ` ` `count1[s1[i] - ` `'a'` `] += 1; ` ` ` `count2[s2[i] - ` `'a'` `] += 1; ` ` ` `} ` ` ` ` ` `// check the difference in characters ` ` ` `// by comparing count arrays ` ` ` `int` `res = 0; ` ` ` `for` `(` `int` `i = 0; i < MAX_CHAR; i++) { ` ` ` `if` `(count1[i] != 0) { ` ` ` `res += ` `abs` `(count1[i] - count2[i]); ` ` ` `} ` ` ` `} ` ` ` `return` `res; ` `} ` ` ` `// driver program ` `int` `main() ` `{ ` ` ` `string s1 = ` `"abc"` `; ` ` ` `string s2 = ` `"cdd"` `; ` ` ` `int` `len = s1.length(); ` ` ` `int` `res = leastCount(s1, s2, len); ` ` ` `cout << res << endl; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// java program to count least number ` `// of manipulations to have two ` `// strings set of same characters ` `import` `java.io.*; ` ` ` `public` `class` `GFG { ` ` ` ` ` `static` `int` `MAX_CHAR = ` `26` `; ` ` ` ` ` `// return the count of manipulations ` ` ` `// required ` ` ` `static` `int` `leastCount(String s1, ` ` ` `String s2, ` `int` `n) ` ` ` `{ ` ` ` ` ` `int` `[] count1 = ` `new` `int` `[MAX_CHAR]; ` ` ` `int` `[] count2 = ` `new` `int` `[MAX_CHAR]; ` ` ` ` ` `// count the number of different ` ` ` `// characters in both strings ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) ` ` ` `{ ` ` ` `count1[s1.charAt(i) - ` `'a'` `] += ` `1` `; ` ` ` `count2[s2.charAt(i) - ` `'a'` `] += ` `1` `; ` ` ` `} ` ` ` ` ` `// check the difference in characters ` ` ` `// by comparing count arrays ` ` ` `int` `res = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < MAX_CHAR; i++) ` ` ` `{ ` ` ` `if` `(count1[i] != ` `0` `) { ` ` ` `res += Math.abs(count1[i] ` ` ` `- count2[i]); ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `res; ` ` ` `} ` ` ` ` ` `// driver program ` ` ` `static` `public` `void` `main(String[] args) ` ` ` `{ ` ` ` `String s1 = ` `"abc"` `; ` ` ` `String s2 = ` `"cdd"` `; ` ` ` `int` `len = s1.length(); ` ` ` `int` `res = leastCount(s1, s2, len); ` ` ` ` ` `System.out.println(res); ` ` ` `} ` `} ` ` ` `// This code is contributed by vt_m. ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to count least number ` `# of manipulations to have two strings ` `# set of same characters ` `MAX_CHAR ` `=` `26` ` ` `# return the count of manipulations ` `# required ` `def` `leastCount(s1, s2, n): ` ` ` ` ` `count1 ` `=` `[` `0` `] ` `*` `MAX_CHAR ` ` ` `count2 ` `=` `[` `0` `] ` `*` `MAX_CHAR ` ` ` ` ` `# count the number of different ` ` ` `# characters in both strings ` ` ` `for` `i ` `in` `range` `( n): ` ` ` `count1[` `ord` `(s1[i]) ` `-` `ord` `(` `'a'` `)] ` `+` `=` `1` ` ` `count2[` `ord` `(s2[i]) ` `-` `ord` `(` `'a'` `)] ` `+` `=` `1` ` ` ` ` `# check the difference in characters ` ` ` `# by comparing count arrays ` ` ` `res ` `=` `0` ` ` `for` `i ` `in` `range` `(MAX_CHAR): ` ` ` `if` `(count1[i] !` `=` `0` `): ` ` ` `res ` `+` `=` `abs` `(count1[i] ` `-` `count2[i]) ` ` ` ` ` `return` `res ` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `s1 ` `=` `"abc"` ` ` `s2 ` `=` `"cdd"` ` ` `l ` `=` `len` `(s1) ` ` ` `res ` `=` `leastCount(s1, s2, l) ` ` ` `print` `(res) ` ` ` `# This code is contributed by ita_c ` |

*chevron_right*

*filter_none*

## C#

`// C# program to count least number ` `// of manipulations to have two strings ` `// set of same characters ` `using` `System; ` ` ` `public` `class` `GFG { ` ` ` ` ` `static` `int` `MAX_CHAR = 26; ` ` ` ` ` `// return the count of manipulations ` ` ` `// required ` ` ` `static` `int` `leastCount(` `string` `s1, ` ` ` `string` `s2, ` `int` `n) ` ` ` `{ ` ` ` ` ` `int` `[] count1 = ` `new` `int` `[MAX_CHAR]; ` ` ` `int` `[] count2 = ` `new` `int` `[MAX_CHAR]; ` ` ` ` ` `// count the number of different ` ` ` `// characters in both strings ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `count1[s1[i] - ` `'a'` `] += 1; ` ` ` `count2[s2[i] - ` `'a'` `] += 1; ` ` ` `} ` ` ` ` ` `// check the difference in characters ` ` ` `// by comparing count arrays ` ` ` `int` `res = 0; ` ` ` `for` `(` `int` `i = 0; i < MAX_CHAR; i++) ` ` ` `{ ` ` ` `if` `(count1[i] != 0) { ` ` ` `res += Math.Abs(count1[i] ` ` ` `- count2[i]); ` ` ` `} ` ` ` `} ` ` ` ` ` `return` `res; ` ` ` `} ` ` ` ` ` `// driver program ` ` ` `static` `public` `void` `Main() ` ` ` `{ ` ` ` `string` `s1 = ` `"abc"` `; ` ` ` `string` `s2 = ` `"cdd"` `; ` ` ` `int` `len = s1.Length; ` ` ` `int` `res = leastCount(s1, s2, len); ` ` ` `Console.WriteLine(res); ` ` ` `} ` `} ` ` ` `// This code is contributed by vt_m. ` |

*chevron_right*

*filter_none*

**Output:**

2

This article is contributed by **Mandeep Singh**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.

## Recommended Posts:

- Minimum Number of Manipulations required to make two Strings Anagram Without Deletion of Character
- Check three or more consecutive identical characters or numbers
- Reduce the string by removing K consecutive identical characters
- Recursive program to insert a star between pair of identical characters
- Remove minimum number of characters so that two strings become anagram
- Count the Number of matching characters in a pair of strings
- Minimum Cost To Make Two Strings Identical
- Count the number of strings in an array whose distinct characters are less than equal to M
- Check if a string can be split into two strings with same number of K-frequent characters
- Find the number of strings formed using distinct characters of a given string
- Find all strings formed from characters mapped to digits of a number
- Minimum Cost to make two Numeric Strings Identical
- Minimum cost to make two strings identical by deleting the digits
- Strings formed from given characters without any consecutive repeating characters
- Replace minimal number of characters to make all characters pair wise distinct
- Minimum number of operations to move all uppercase characters before all lower case characters
- Permutation of a string with maximum number of characters greater than its adjacent characters
- Common characters in n strings
- Count of sub-strings that do not contain all the characters from the set {'a', 'b', 'c'} at the same time
- Count common characters in two strings