# Number of palindromic permutations | Set 1

Given a 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is based on below facts :

• A string can permute to a palindrome if number of odd occurring characters are 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. 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 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!).

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

 ` `

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.

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Improved By : JainHarshit, jit_t, manishshaw1