Skip to content
Related Articles

Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Count of distinct permutation of a String obtained by swapping only unequal characters

  • Difficulty Level : Medium
  • Last Updated : 10 Aug, 2021

Given a string find the number of unique permutations that can be obtained by swapping two indices such that the elements at these indices are distinct.

NOTE: Swapping is always performed in the original string.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Examples:



Input: str = “sstt”
Output: 5
Explaination: 
Swap str[0] with str[2], string obtained “tsst” which is valid (str[0]!=str[2])
Swap str[0] with str[3]. string obtained “tsts”
Swap str[1] with str[2], string obtained “stst”
Swap str[1] with str[3], string obtained “stts”
Hence total 5 strings can be obtained including the given string (“sstt”)

Input: str = “abcd”
Output: 7

Approach: The problem can be solved using HashMap by the following steps:

  1. Create a hashmap and store the frequency of every character of the given string.
  2. Create a variable count, to store the total number of characters in the given string, i.e. count=str.length() and a variable ans to store the number of unique permutations possible and initialize ans=0.
  3. Traverse the string and for each character:
    • Find the number of different characters present in the right of the current index. This can be done by subtracting the frequency of that character by the total count.
    • Now add this calculated value to ans, as this is the number of characters with which the current character can be swapped to create a unique permutation.
    • Now, Reduce the frequency of the current character and count by 1, so that it cannot interfere with the calculations of the same elements present to the right of it.
  4. Return ans+1, because the given string is also a unique permutation.

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate total
// number of valid permutations
int validPermutations(string str)
{
    unordered_map<char, int> m;
 
    // Creating count which is equal to the
    // Total number of characters present and
    // ans that will store the number of unique
    // permutations
    int count = str.length(), ans = 0;
 
    // Storing frequency of each character
    // present in the string
    for (int i = 0; i < str.length(); i++) {
        m[str[i]]++;
    }
    for (int i = 0; i < str.length(); i++) {
        // Adding count of characters by excluding
        // characters equal to current char
        ans += count - m[str[i]];
 
        // Reduce the frequency of the current character
        // and count by 1, so that it cannot interfere
        // with the calculations of the same elements
        // present to the right of it.
        m[str[i]]--;
        count--;
    }
 
    // Return ans+1 (Because the given string
    // is also a unique permutation)
    return ans + 1;
}
 
// Driver Code
int main()
{
    string str = "sstt";
    cout << validPermutations(str);
    return 0;
}
Java



// Java program for the above approach
 
// Importing HashMap class
import java.util.HashMap;
 
class GFG {
 
    // Function to calculate total
    // number of valid permutations
    static int validPermutations(String str)
    {
 
        HashMap<Character, Integer> m
            = new HashMap<Character, Integer>();
 
        // Creating count which is equal to the
        // Total number of characters present and
        // ans that will store the number of unique
        // permutations
        int count = str.length(), ans = 0;
 
        // Storing frequency of each character
        // present in the string
        for (int i = 0; i < str.length(); i++) {
            m.put(str.charAt(i),
                  m.getOrDefault(str.charAt(i), 0) + 1);
        }
 
        for (int i = 0; i < str.length(); i++) {
            // Adding count of characters by excluding
            // characters equal to current char
            ans += count - m.get(str.charAt(i));
 
            // Reduce the frequency of the current character
            // and count by 1, so that it cannot interfere
            // with the calculations of the same elements
            // present to the right of it.
            m.put(str.charAt(i), m.get(str.charAt(i)) - 1);
            count--;
        }
 
        // Return ans+1 (Because the given string
        // is also a unique permutation)
        return ans + 1;
    }
 
    public static void main(String[] args)
    {
        String str = "sstt";
 
        System.out.println(validPermutations(str));
    }
}
 
// This code is contributed by rajsanghavi9.
Python3



# Python 3 program for the above approach
 
# Function to calculate total
# number of valid permutations
def validPermutations(str):
    m = {}
 
    # Creating count which is equal to the
    # Total number of characters present and
    # ans that will store the number of unique
    # permutations
    count = len(str)
    ans = 0
 
    # Storing frequency of each character
    # present in the string
    for i in range(len(str)):
        if(str[i] in m):
            m[str[i]] += 1
        else:
            m[str[i]] = 1
    for i in range(len(str)):
       
        # Adding count of characters by excluding
        # characters equal to current char
        ans += count - m[str[i]]
 
        # Reduce the frequency of the current character
        # and count by 1, so that it cannot interfere
        # with the calculations of the same elements
        # present to the right of it.
        m[str[i]] -= 1
        count -= 1
 
    # Return ans+1 (Because the given string
    # is also a unique permutation)
    return ans + 1
 
# Driver Code
if __name__ == '__main__':
    str = "sstt"
    print(validPermutations(str))
 
    # This code is contributed by SURENDRA_GANGWAR.
C#



// C# program for the above approach
 
// Importing Dictionary class
using System;
using System.Collections.Generic;
 
 
public class GFG {
 
    // Function to calculate total
    // number of valid permutations
    static int validPermutations(String str)
    {
 
        Dictionary<char, int> m
            = new Dictionary<char, int>();
 
        // Creating count which is equal to the
        // Total number of characters present and
        // ans that will store the number of unique
        // permutations
        int count = str.Length, ans = 0;
 
        // Storing frequency of each character
        // present in the string
        for (int i = 0; i < str.Length; i++) {
            if(m.ContainsKey(str[i]))
                m[str[i]]=m[str[i]]+1;
            else
                m.Add(str[i], 1);
        }
 
        for (int i = 0; i < str.Length; i++) {
            // Adding count of characters by excluding
            // characters equal to current char
            ans += count - m[str[i]];
 
            // Reduce the frequency of the current character
            // and count by 1, so that it cannot interfere
            // with the calculations of the same elements
            // present to the right of it.
            if(m.ContainsKey(str[i]))
                m[str[i]]=m[str[i]]-1;
            count--;
        }
 
        // Return ans+1 (Because the given string
        // is also a unique permutation)
        return ans + 1;
    }
 
    public static void Main(String[] args)
    {
        String str = "sstt";
 
        Console.WriteLine(validPermutations(str));
    }
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
 
// JavaScript program for the above approach
 
// Function to calculate total
// number of valid permutations
function validPermutations(str) {
  let m = new Map();
 
  // Creating count which is equal to the
  // Total number of characters present and
  // ans that will store the number of unique
  // permutations
  let count = str.length,
    ans = 0;
 
  // Storing frequency of each character
  // present in the string
  for (let i = 0; i < str.length; i++) {
    if (m.has(str[i])) {
      m.set(str[i], m.get(str[i]) + 1);
    } else {
      m.set(str[i], 1);
    }
  }
  for (let i = 0; i < str.length; i++)
  {
   
    // Adding count of characters by excluding
    // characters equal to current char
    ans += count - m.get(str[i]);
 
 
    // Reduce the frequency of the current character
    // and count by 1, so that it cannot interfere
    // with the calculations of the same elements
    // present to the right of it.
    m.set(str[i], m.get(str[i]) - 1);
    count--;
  }
 
  // Return ans+1 (Because the given string
  // is also a unique permutation)
  return ans + 1;
}
 
// Driver Code
let str = "sstt";
document.write(validPermutations(str));
 
</script>
 
 
Output: 
5
 
 Time Complexity: O(n)
Auxiliary Space: O(n)



My Personal Notes
arrow_drop_up
Previous
Rearrange the Array by shifting middle elements to start and end alternatively
Next

Maximize the profit after selling the tickets | Set 2 (For elements in range [1, 10^6])
Recommended Articles
Page :
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Check if two binary strings can be made equal by swapping pairs of unequal characters
20, Jan 21
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Maximize given integer by swapping pairs of unequal bits
29, Jan 21
Longest Common Subsequence (LCS) by repeatedly swapping characters of a string with characters of another string
22, Mar 21
Check if a permutation of S2 can be obtained by adding or removing characters from S1
29, Jun 21
Minimum replacements to make adjacent characters unequal in a ternary string
24, Jan 19
Minimum replacements to make adjacent characters unequal in a ternary string | Set-2
08, Feb 19
Minimum replacements in a string to make adjacent characters unequal
22, Jul 20
Count of ungrouped characters after dividing a string into K groups of distinct characters
14, May 20
Convert given string so that it holds only distinct characters
09, Jan 19
Permutation of a string with maximum number of characters greater than its adjacent characters
18, Jul 18
Find distinct characters in distinct substrings of a string
05, Jul 19
Count different Bitwise OR values of equal length strings S1 and S2 by swapping exactly one pair of characters from the first string
27, Jun 21
Modify string by inserting characters such that every K-length substring consists of unique characters only
14, Feb 21
Check if a string can be made equal to another string by swapping or replacement of characters
24, Jan 21
Minimum swaps to make two strings equal by swapping only with third string
04, Apr 20
Distinct Numbers obtained by generating all permutations of a Binary String
05, Apr 21
String with k distinct characters and no same characters adjacent
25, Oct 17
Count of distinct Strings possible by swapping prefixes of pairs of Strings from the Array
18, Aug 20
Lexicographically largest subsequence containing all distinct characters only once
18, Aug 21
Lexicographically smallest permutation of length 2N that can be obtained from an N-length array satisfying given conditions
17, Jun 21
Largest string obtained in Dictionary order after deleting K characters
10, Aug 20
Count numbers in range such that digits in it and it's product with q are unequal
13, Nov 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
akvs
@akvs
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox