Skip to content
Related Articles

Related Articles

Improve Article

Find longest palindrome formed by removing or shuffling chars from string

  • Difficulty Level : Medium
  • Last Updated : 12 Jun, 2021

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

 

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.

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 <bits/stdc++.h>
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[256] = { 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 string
 
# Function to find the longest palindrome by removing
# or shuffling characters from the given string
def findLongestPalindrome(strr):
     
    # to stores freq of characters in a string
    count = [0]*256
 
    # find freq of characters in the input string
    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 string. 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
            # string
            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 string
    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[256];
 
        // 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

Javascript




<script>
 
// Javascript program to find the
// longest palindrome by removing
// or shuffling characters from
// the given string
 
// Function to find the longest
// palindrome by removing
// or shuffling characters from
// the given string
    function findLongestPalindrome(str)
    {
        // to stores freq of characters
        // in a string
        let count = new Array(256);
        for(let i=0;i<256;i++)
        {
            count[i]=0;
        }
   
        // find freq of characters in
        // the input string
        for (let i = 0; i < str.length; i++) {
            count[str[i].charCodeAt(0)]++;
        }
   
        // Any palindromic string consists
        // of three parts
        // beg + mid + end
        let beg = "", mid = "", end = "";
   
        // solution assumes only
        // lowercase characters are
        // present in string.
        // We can easily extend this
        // to consider any set of characters
        for (let ch = 'a'.charCodeAt(0);
        ch <= 'z'.charCodeAt(0); 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.fromCharCode(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 (let i = 0; i < count[ch] / 2; i++)
                {
                    beg += String.fromCharCode(ch);
                }
            }
        }
   
        // end will be reverse of beg
        end = beg;
        end = reverse(end);
   
        // return palindrome string
        return beg + mid + end;
    }
     
    function reverse(str)
    {
        // convert String to character array
        // by using toCharArray
        let ans = "";
        let try1 = str.split("");
   
        for (let i = try1.length - 1; i >= 0; i--) {
            ans += try1[i];
        }
        return ans;
    }
     
    // Driver code
    let str = "abbaccd";
    document.write(findLongestPalindrome(str));
     
    // This code is contributed by unknown2108
     
</script>

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.
This article is contributed by Aditya Goel. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :