# Find longest palindrome formed by removing or shuffling chars from string

Given a string, find the longest palindrome that can be constructed by removing or shuffling characters from the string. Return only one palindrome if there are multiple palindrome strings of longest length.

Examples:

```Input:  abc
Output: a OR b OR c

Input:  aabbcc
Output: abccba OR baccab OR cbaabc OR
any other palindromic string of length 6.

Input:  abbaccd
Output: abcdcba OR ...

Input:  aba
Output: aba
```

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

We can divide any palindromic string into three parts – beg, mid and end. For palindromic string of odd length say 2n + 1, ‘beg’ consists of first n characters of the string, ‘mid’ will consist of only 1 character i.e. (n + 1)th character and ‘end’ will consists of last n characters of the palindromic string. For palindromic string of even length 2n, ‘mid’ will always be empty. It should be noted that ‘end’ will be reverse of ‘beg’ in order for string to be palindrome.

The idea is to use above observation in our solution. As shuffling of characters is allowed, order of characters doesn’t matter in the input string. We first get frequency of each character in the input string. Then all characters having even occurrence (say 2n) in the input string will be part of the output string as we can easily place n characters in ‘beg’ string and the other n characters in the ‘end’ string (by preserving the palindromic order). For characters having odd occurrence (say 2n + 1), we fill ‘mid’ with one of all such characters. and remaining 2n characters are divided in halves and added at beginning and end.

Below is the implementation of above idea –

## C++

 `// C++ program to find the longest palindrome by removing ` `// or shuffling characters from the given string ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the longest palindrome by removing ` `// or shuffling characters from the given string ` `string findLongestPalindrome(string str) ` `{ ` `    ``// to stores freq of characters in a string ` `    ``int` `count = { 0 }; ` ` `  `    ``// find freq of characters in the input string ` `    ``for` `(``int` `i = 0; i < str.size(); i++) ` `        ``count[str[i]]++; ` ` `  `    ``// Any palindromic string consists of three parts ` `    ``// beg + mid + end ` `    ``string beg = ``""``, mid = ``""``, end = ``""``; ` ` `  `    ``// solution assumes only lowercase characters are ` `    ``// present in string. We can easily extend this ` `    ``// to consider any set of characters ` `    ``for` `(``char` `ch = ``'a'``; ch <= ``'z'``; ch++) ` `    ``{ ` `        ``// if the current character freq is odd ` `        ``if` `(count[ch] & 1) ` `        ``{ ` `            ``// mid will contain only 1 character. It ` `            ``// will be overridden with next character ` `            ``// with odd freq ` `            ``mid = ch; ` ` `  `            ``// decrement the character freq to make ` `            ``// it even and consider current character ` `            ``// again ` `            ``count[ch--]--; ` `        ``} ` ` `  `        ``// if the current character freq is even ` `        ``else` `        ``{ ` `            ``// If count is n(an even number), push ` `            ``// n/2 characters to beg string and rest ` `            ``// n/2 characters will form part of end ` `            ``// string ` `            ``for` `(``int` `i = 0; i < count[ch]/2 ; i++) ` `                ``beg.push_back(ch); ` `        ``} ` `    ``} ` ` `  `    ``// end will be reverse of beg ` `    ``end = beg; ` `    ``reverse(end.begin(), end.end()); ` ` `  `    ``// return palindrome string ` `    ``return` `beg + mid + end; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"abbaccd"``; ` ` `  `    ``cout << findLongestPalindrome(str); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find the longest palindrome by removing ` `// or shuffling characters from the given string ` ` `  `class` `GFG { ` ` `  `// Function to find the longest palindrome by removing ` `// or shuffling characters from the given string ` `    ``static` `String findLongestPalindrome(String str) { ` `        ``// to stores freq of characters in a string ` `        ``int` `count[] = ``new` `int``[``256``]; ` ` `  `        ``// find freq of characters in the input string ` `        ``for` `(``int` `i = ``0``; i < str.length(); i++) { ` `            ``count[str.charAt(i)]++; ` `        ``} ` ` `  `        ``// Any palindromic string consists of three parts ` `        ``// beg + mid + end ` `        ``String beg = ``""``, mid = ``""``, end = ``""``; ` ` `  `        ``// solution assumes only lowercase characters are ` `        ``// present in string. We can easily extend this ` `        ``// to consider any set of characters ` `        ``for` `(``char` `ch = ``'a'``; ch <= ``'z'``; ch++) { ` `            ``// if the current character freq is odd ` `            ``if` `(count[ch] % ``2` `== ``1``) { ` `                ``// mid will contain only 1 character. It ` `                ``// will be overridden with next character ` `                ``// with odd freq ` `                ``mid = String.valueOf(ch); ` ` `  `                ``// decrement the character freq to make ` `                ``// it even and consider current character ` `                ``// again ` `                ``count[ch--]--; ` `            ``} ``// if the current character freq is even ` `            ``else` `{ ` `                ``// If count is n(an even number), push ` `                ``// n/2 characters to beg string and rest ` `                ``// n/2 characters will form part of end ` `                ``// string ` `                ``for` `(``int` `i = ``0``; i < count[ch] / ``2``; i++) { ` `                    ``beg += ch; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// end will be reverse of beg ` `        ``end = beg; ` `        ``end = reverse(end); ` ` `  `        ``// return palindrome string ` `        ``return` `beg + mid + end; ` `    ``} ` ` `  `    ``static` `String reverse(String str) { ` `        ``// convert String to character array  ` `        ``// by using toCharArray  ` `        ``String ans = ``""``; ` `        ``char``[] try1 = str.toCharArray(); ` ` `  `        ``for` `(``int` `i = try1.length - ``1``; i >= ``0``; i--) { ` `            ``ans += try1[i]; ` `        ``} ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) { ` `        ``String str = ``"abbaccd"``; ` `        ``System.out.println(findLongestPalindrome(str)); ` `    ``} ` `} ` `// This code is contributed by PrinciRaj1992 `

## Python3

 `# Python3 program to find the longest palindrome by removing ` `# or shuffling characters from the given strring ` ` `  `# Function to find the longest palindrome by removing ` `# or shuffling characters from the given strring ` `def` `findLongestPalindrome(strr): ` `     `  `    ``# to stores freq of characters in a strring ` `    ``count ``=` `[``0``]``*``256` ` `  `    ``# find freq of characters in the input strring ` `    ``for` `i ``in` `range``(``len``(strr)): ` `        ``count[``ord``(strr[i])] ``+``=` `1` ` `  `    ``# Any palindromic consists of three parts ` `    ``# beg + mid + end ` `    ``beg ``=` `"" ` `    ``mid ``=` `"" ` `    ``end ``=` `"" ` ` `  `    ``# solution assumes only lowercase characters are ` `    ``# present in strring. We can easily extend this ` `    ``# to consider any set of characters ` `    ``ch ``=` `ord``(``'a'``) ` `    ``while` `ch <``=` `ord``(``'z'``): ` `         `  `        ``# if the current character freq is odd ` `        ``if` `(count[ch] & ``1``): ` `             `  `            ``# mid will contain only 1 character. It ` `            ``# will be overridden with next character ` `            ``# with odd freq ` `            ``mid ``=` `ch ` ` `  `            ``# decrement the character freq to make ` `            ``# it even and consider current character ` `            ``# again ` `            ``count[ch] ``-``=` `1` `            ``ch ``-``=` `1` ` `  `        ``# if the current character freq is even ` `        ``else``: ` `         `  `            ``# If count is n(an even number), push ` `            ``# n/2 characters to beg and rest ` `            ``# n/2 characters will form part of end ` `            ``# strring ` `            ``for` `i ``in` `range``(count[ch]``/``/``2``): ` `                ``beg ``+``=` `chr``(ch) ` `        ``ch ``+``=` `1` ` `  `    ``# end will be reverse of beg ` `    ``end ``=` `beg ` ` `  `    ``end ``=` `end[::``-``1``] ` ` `  `    ``# return palindrome strring ` `    ``return` `beg ``+` `chr``(mid) ``+` `end ` ` `  `# Driver code ` `strr ``=` `"abbaccd"` ` `  `print``(findLongestPalindrome(strr)) ` ` `  `# This code is contributed by mohit kumar 29 `

## C#

 `// C# program to find the longest  ` `// palindrome by removing or ` `// shuffling characters from  ` `// the given string ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `    ``// Function to find the longest  ` `    ``// palindrome by removing or  ` `    ``// shuffling characters from  ` `    ``// the given string ` `    ``static` `String findLongestPalindrome(String str)  ` `    ``{ ` `        ``// to stores freq of characters in a string ` `        ``int` `[]count = ``new` `int``; ` ` `  `        ``// find freq of characters  ` `        ``// in the input string ` `        ``for` `(``int` `i = 0; i < str.Length; i++)  ` `        ``{ ` `            ``count[str[i]]++; ` `        ``} ` ` `  `        ``// Any palindromic string consists of  ` `        ``// three parts beg + mid + end ` `        ``String beg = ``""``, mid = ``""``, end = ``""``; ` ` `  `        ``// solution assumes only lowercase  ` `        ``// characters are present in string. ` `        ``// We can easily extend this to  ` `        ``// consider any set of characters ` `        ``for` `(``char` `ch = ``'a'``; ch <= ``'z'``; ch++)  ` `         `  `        ``{ ` `            ``// if the current character freq is odd ` `            ``if` `(count[ch] % 2 == 1)   ` `            ``{ ` `                 `  `                ``// mid will contain only 1 character.  ` `                ``// It will be overridden with next  ` `                ``// character with odd freq ` `                ``mid = String.Join(``""``,ch); ` ` `  `                ``// decrement the character freq to make ` `                ``// it even and consider current  ` `                ``// character again ` `                ``count[ch--]--; ` `            ``}  ` `             `  `            ``// if the current character freq is even ` `            ``else`  `            ``{ ` `                 `  `                ``// If count is n(an even number), push ` `                ``// n/2 characters to beg string and rest ` `                ``// n/2 characters will form part of end ` `                ``// string ` `                ``for` `(``int` `i = 0; i < count[ch] / 2; i++)  ` `                ``{ ` `                    ``beg += ch; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// end will be reverse of beg ` `        ``end = beg; ` `        ``end = reverse(end); ` ` `  `        ``// return palindrome string ` `        ``return` `beg + mid + end; ` `    ``} ` ` `  `    ``static` `String reverse(String str)  ` `    ``{ ` `        ``// convert String to character array  ` `        ``// by using toCharArray  ` `        ``String ans = ``""``; ` `        ``char``[] try1 = str.ToCharArray(); ` ` `  `        ``for` `(``int` `i = try1.Length - 1; i >= 0; i--)  ` `        ``{ ` `            ``ans += try1[i]; ` `        ``} ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main()  ` `    ``{ ` `        ``String str = ``"abbaccd"``; ` `        ``Console.WriteLine(findLongestPalindrome(str)); ` `    ``} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```abcdcba
```

Time complexity of above solution is O(n) where n is length of the string. Since, number of characters in the alphabet is constant, they do not contribute to asymptotic analysis.

Auxiliary space used by the program is M where M is number of ASCII characters.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.