 GeeksforGeeks App
Open App Browser
Continue

# Number of palindromic permutations | Set 1

Given string str, find count of all palindromic permutations of it.

Examples :

```Input : str = "gfgf"
Output : 2
There are two palindromic
permutations fggf and gffg

Input : str = "abc"
Output : 0```

The idea is based on below facts :

• A string can permute to a palindrome if number of odd occurring characters is at most one.
• One occurrence of the only odd character always goes to middle.
• Half of counts of all characters decide the result. In case of odd occurring character, it is floor of half. The other half is automatically decided

For example, if input string is “aabbccd”, the count of palindromic permutations is 3! (We get three by taking floor of half of all counts)

What if half itself has repeated characters?
We apply a simple combinatorial rule and divide by factorial of half.
For example “aaaaaabbbb”, floor of half of string is 5. In half of a palindromic string, ‘a’ is repeated three times and ‘b’ is repeated two times, so our result is (5!) / (2!) * (3!).

Implementation:

## C++

 `// CPP program to find number of``// palindromic permutations of a``// given string``#include ``using` `namespace` `std;` `const` `int` `MAX = 256;` `// Returns factorial of n``long` `long` `int` `fact(``int` `n)``{``    ``long` `long` `int` `res = 1;``    ``for` `(``int` `i = 2; i <= n; i++)``        ``res = res * i;``    ``return` `res;``}` `// Returns count of palindromic``// permutations of str.``int` `countPalinPermutations(string &str)``{``    ``// Count frequencies of all characters``    ``int` `n = str.length();``    ``int` `freq[MAX] = { 0 };``    ``for` `(``int` `i = 0; i < n; i++)``        ``freq[str[i]]++;` `    ``// Since half of the characters``    ``// decide count of palindromic``    ``// permutations, we take (n/2)!``    ``long` `long` `int` `res = fact(n / 2);` `    ``// To make sure that there is at``    ``// most one odd occurring char``    ``bool` `oddFreq = ``false``;` `    ``// Traverse through all counts``    ``for` `(``int` `i = 0; i < MAX; i++) {``        ``int` `half = freq[i] / 2;` `        ``// To make sure that the``        ``// string can permute to``        ``// form a palindrome``        ``if` `(freq[i] % 2 != 0) {` `            ``// If there are more than``            ``// one odd occurring chars``            ``if` `(oddFreq == ``true``)``                ``return` `0;``            ``oddFreq = ``true``;``        ``}` `        ``// Divide all permutations with``        ``// repeated characters``        ``res = res / fact(half);``    ``}` `    ``return` `res;``}` `// Driver code``int` `main()``{``    ``string str = ``"gffg"``;``    ``cout << countPalinPermutations(str);``    ``return` `0;``}`

## Java

 `// Java program to find number of``// palindromic permutations of a``// given string``class` `GFG {``    ` `    ``static` `final` `int` `MAX = ``256``;``    ` `    ``// Returns factorial of n``    ``static` `long` `fact(``int` `n)``    ``{``        ``long` `res = ``1``;``        ` `        ``for` `(``int` `i = ``2``; i <= n; i++)``            ``res = res * i;``            ` `        ``return` `res;``    ``}``    ` `    ``// Returns count of palindromic``    ``// permutations of str.``    ``static` `int` `countPalinPermutations(String str)``    ``{``        ` `        ``// Count frequencies of all characters``        ``int` `n = str.length();``        ``int` `freq[]=``new` `int``[MAX];``        ` `        ``for` `(``int` `i = ``0``; i < n; i++)``            ``freq[str.charAt(i)]++;``    ` `        ``// Since half of the characters``        ``// decide count of palindromic``        ``// permutations, we take (n/2)!``        ``long` `res = fact(n / ``2``);``    ` `        ``// To make sure that there is at``        ``// most one odd occurring char``        ``boolean` `oddFreq = ``false``;``    ` `        ``// Traverse through all counts``        ``for` `(``int` `i = ``0``; i < MAX; i++) {``            ``int` `half = freq[i] / ``2``;``    ` `            ``// To make sure that the``            ``// string can permute to``            ``// form a palindrome``            ``if` `(freq[i] % ``2` `!= ``0``) {``    ` `                ``// If there are more than``                ``// one odd occurring chars``                ``if` `(oddFreq == ``true``)``                    ``return` `0``;``                    ` `                ``oddFreq = ``true``;``            ``}``    ` `            ``// Divide all permutations with``            ``// repeated characters``            ``res = res / fact(half);``        ``}``    ` `        ``return` `(``int``)res;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ` `        ``String str = ``"gffg"``;``        ` `        ``System.out.print(``            ``countPalinPermutations(str));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python3

 `# Python3 program to find number of``# palindromic permutations of a``# given string``MAX` `=` `256`` ` `# Returns factorial of n``def` `fact(n) :``    ``res ``=` `1``    ``for` `i ``in` `range``(``2``, n``+``1``) :``        ``res ``=` `res ``*` `i``    ``return` `res`` ` `# Returns count of palindromic``# permutations of str.``def` `countPalinPermutations(``str``) :``    ``global` `MAX``     ` `    ``# Count frequencies of``    ``# all characters``    ``n ``=` `len``(``str``)``    ``freq ``=` `[``0``] ``*` `MAX``;``    ``for` `i ``in` `range``(``0``, n) :``        ``freq[``ord``(``str``[i])] ``=` `freq[``ord``(``str``[i])] ``+` `1``;``    ``# Since half of the characters``    ``# decide count of palindromic``    ``# permutations, we take (n/2)!``    ``res ``=` `fact(``int``(n ``/` `2``))`` ` `    ``# To make sure that there is at``    ``# most one odd occurring char``    ``oddFreq ``=` `False`` ` `    ``# Traverse through all counts``    ``for` `i ``in` `range``(``0``, ``MAX``) :``        ``half ``=` `int``(freq[i] ``/` `2``)`` ` `        ``# To make sure that the``        ``# string can permute to``        ``# form a palindrome``        ``if` `(freq[i] ``%` `2` `!``=` `0``):`` ` `            ``# If there are more than``            ``# one odd occurring chars``            ``if` `(oddFreq ``=``=` `True``):``                ``return` `0``            ``oddFreq ``=` `True`` ` `        ``# Divide all permutations``        ``# with repeated characters``        ``res ``=` `int``(res ``/` `fact(half))`` ` `    ``return` `res`` ` `# Driver code``str` `=` `"gffg"``print` `(countPalinPermutations(``str``))`` ` `# This code is contributed by Manish Shaw``# (manishshaw1)`

## C#

 `// C# program to find number of``// palindromic permutations of a``// given string``using` `System;` `class` `GFG {``    ` `    ``static` `int` `MAX = 256;``    ` `    ``// Returns factorial of n``    ``static` `long` `fact(``int` `n)``    ``{``        ``long` `res = 1;``        ` `        ``for` `(``int` `i = 2; i <= n; i++)``            ``res = res * i;``            ` `        ``return` `res;``    ``}``    ` `    ``// Returns count of palindromic``    ``// permutations of str.``    ``static` `int` `countPalinPermutations(``string` `str)``    ``{``        ` `        ``// Count frequencies of all characters``        ``int` `n = str.Length;``        ``int` `[]freq=``new` `int``[MAX];``        ` `        ``for` `(``int` `i = 0; i < n; i++)``            ``freq[str[i]]++;``    ` `        ``// Since half of the characters``        ``// decide count of palindromic``        ``// permutations, we take (n/2)!``        ``long` `res = fact(n / 2);``    ` `        ``// To make sure that there is at``        ``// most one odd occurring char``        ``bool` `oddFreq = ``false``;``    ` `        ``// Traverse through all counts``        ``for` `(``int` `i = 0; i < MAX; i++) {``            ``int` `half = freq[i] / 2;``    ` `            ``// To make sure that the``            ``// string can permute to``            ``// form a palindrome``            ``if` `(freq[i] % 2 != 0) {``    ` `                ``// If there are more than``                ``// one odd occurring chars``                ``if` `(oddFreq == ``true``)``                    ``return` `0;``                    ` `                ``oddFreq = ``true``;``            ``}``    ` `            ``// Divide all permutations with``            ``// repeated characters``            ``res = res / fact(half);``        ``}``    ` `        ``return` `(``int``)res;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ` `        ``string` `str = ``"gffg"``;``        ` `        ``Console.WriteLine(``            ``countPalinPermutations(str));``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output :

`2`

The above solution causes overflow very early. We can avoid overflow by doing modular arithmetic. In the next article, we would be discussing modular arithmetic-based approach.

My Personal Notes arrow_drop_up