# Count of distinct strings that can be obtained after performing exactly one swap

Given a string s containing lowercase English alphabet characters. The task is to calculate the number of distinct strings that can be obtained after performing exactly one swap.

Input: s = “geek”
Output: 6
Explanation: Following are the strings formed by doing exactly one swap
strings = [“egek”,”eegk”,”geek”,”geke”,”gkee”, “keeg”]
Therefore, there are 6 distinct possible strings.

Input: s = “ab”
Output: 1

Approach: This problem can be solved by using HashMaps. Follow the steps below to solve the given problem.

• Check for the number of unique elements in the string s.
• Store the frequencies of all the unique characters in a map.
• Declare a variable say ans = 0, to store the number of distinct possible strings.
• Iterate over the string and increment ans by no of elements apart from the current element which will be used to construct a new string.
• Iterate over the string again and check if the frequency of some characters is greater than 2. If so then increment answer by 1 as they will be forming only one extra unique string.
• Return ans as the final answer.

Below is the implementation of the above approach

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to count number of distinct``// string formed after one swap``long` `long` `countStrings(string S)``{``    ``long` `long` `N = S.size();` `    ``// mp[] to store the frequency ``    ``// of each character``    ``int` `mp[26] = { 0 };` `    ``// For storing frequencies``    ``for` `(``auto` `i : S) {``        ``mp[i - ``'a'``]++;``    ``}``    ``long` `long` `ans = 0;``    ``for` `(``auto` `i : S) {``        ``ans += N - mp[i - ``'a'``];``    ``}``    ``ans /= 2;` `    ``for` `(``int` `i = 0; i < 26; i++) {``        ``if` `(mp[i] >= 2) {``            ``ans++;``            ``break``;``        ``}``    ``}``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``string S = ``"geek"``;` `    ``// Function Call``    ``long` `long` `ans = countStrings(S);``    ``cout << ans << endl;` `    ``return` `0;``}`

## Java

 `// Java code to implement the above approach``import` `java.util.*;``public` `class` `GFG``{``  ` `// Function to count number of distinct``// string formed after one swap``static` `long` `countStrings(String S)``{``    ``long` `N = S.length();` `    ``// mp[] to store the frequency ``    ``// of each character``    ``int` `mp[] = ``new` `int``[``26``];``    ``for``(``int` `i = ``0``; i < ``26``; i++) {``        ``mp[i] = ``0``;``    ``}` `    ``// For storing frequencies``    ``for` `(``int` `i = ``0``; i < S.length(); i++) {``        ``mp[S.charAt(i) - ``'a'``]++;``    ``}``    ``long` `ans = ``0``;``    ``for` `(``int` `i = ``0``; i < S.length(); i++) {``        ``ans += N - mp[S.charAt(i) - ``'a'``];``    ``}``    ``ans /= ``2``;` `    ``for` `(``int` `i = ``0``; i < ``26``; i++) {``        ``if` `(mp[i] >= ``2``) {``            ``ans++;``            ``break``;``        ``}``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``String S = ``"geek"``;` `    ``// Function Call``    ``long` `ans = countStrings(S);``    ``System.out.println(ans);``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python code to implement the above approach` `# Function to count number of distinct``# string formed after one swap``def` `countStrings(S):``    ``N ``=` `len``(S);` `    ``# mp to store the frequency``    ``# of each character``    ``mp ``=` `[``0` `for` `i ``in` `range``(``26``)];``    ``for` `i ``in` `range``(``26``):``        ``mp[i] ``=` `0``;` `    ``# For storing frequencies``    ``for` `i ``in` `range``(N):``        ``mp[``ord``(S[i]) ``-` `ord``(``'a'``)] ``+``=` `1``;` `    ``ans ``=` `0``;``    ``for` `i ``in` `range``(N):``        ``ans ``+``=` `N ``-` `mp[``ord``(S[i]) ``-` `ord``(``'a'``)];` `    ``ans ``/``/``=` `2``;` `    ``for` `i ``in` `range``(``26``):``        ``if` `(mp[i] >``=` `2``):``            ``ans ``+``=` `1``;``            ``break``;` `    ``return` `ans;` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``S ``=` `"geek"``;` `    ``# Function Call``    ``ans ``=` `countStrings(S);``    ``print``(ans);` `# This code is contributed by 29AjayKumar`

## C#

 `// C# code to implement the above approach``using` `System;``class` `GFG``{``  ` `// Function to count number of distinct``// string formed after one swap``static` `long` `countStrings(``string` `S)``{``    ``long` `N = S.Length;` `    ``// mp[] to store the frequency ``    ``// of each character``    ``int` `[]mp = ``new` `int``[26];``    ``for``(``int` `i = 0; i < 26; i++) {``        ``mp[i] = 0;``    ``}` `    ``// For storing frequencies``    ``for` `(``int` `i = 0; i < S.Length; i++) {``        ``mp[S[i] - ``'a'``]++;``    ``}``    ``long` `ans = 0;``    ``for` `(``int` `i = 0; i < S.Length; i++) {``        ``ans += N - mp[S[i] - ``'a'``];``    ``}``    ``ans /= 2;` `    ``for` `(``int` `i = 0; i < 26; i++) {``        ``if` `(mp[i] >= 2) {``            ``ans++;``            ``break``;``        ``}``    ``}``    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main()``{``    ``string` `S = ``"geek"``;` `    ``// Function Call``    ``long` `ans = countStrings(S);``    ``Console.Write(ans);``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output
`6`

Time Complexity: O(N), as we are using a loop to traverse N times so it will cost us O(N) time.
Auxiliary Space: O(1), as we are not using any extra space.

Previous
Next