# Number of palindromic permutations | Set 1

• Difficulty Level : Hard
• Last Updated : 03 May, 2021

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

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.

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!).

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