Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Longest palindromic String formed using concatenation of given strings in any order

  • Difficulty Level : Medium
  • Last Updated : 26 May, 2021

Given an array of strings arr[] of the same length, the task is to find the longest palindromic string that can be made using the concatenation of strings in any order. 

Examples:

Input: arr[] = {“aba”, “aba”} 
Output: abaaba

Input: arr[] = {“abc”, “dba”, “kop”, “cba”, “abd”} 
Output: abcdbaabdcba 
 

Approach:  

  • Find all the pairs of strings which are reverse of each other and store them in two different arrays pair1[] and pair2 separately and delete those pairs from the original array.
  • Find any palindromic string s1 in the array.
  • Join all the strings together of the array pair1[] into s2
  • Join all the strings together of the array pair2[] in reverse order into s3
  • Concatenate the strings s2 + s1 + s3 together to get longest palindromic string.

Below is the implementation of the above approach.

C++




// C++ implementation to find the longest
// palindromic String formed using
// concatenation of given strings in any order
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the longest palindromic
// from given array of strings
void longestPalindrome(string a[],
                       int n)
{
    string pair1[n];
    string pair2[n];
    int r = 0;
 
    // Loop to find the pair of strings
    // which are reverse of each other
    for (int i = 0; i < n; i++) {
        string s = a[i];
        reverse(s.begin(), s.end());
        for (int j = i + 1; j < n; j++) {
            if (a[i] != "" && a[j] != "") {
                if (s == a[j]) {
                    pair1[r] = a[i];
                    pair2[r++] = a[j];
                    a[i] = "";
                    a[j] = "";
                    break;
                }
            }
        }
    }
    string s1 = "";
 
    // Loop to find if any palindromic
    // string is still left in the array
    for (int i = 0; i < n; i++) {
        string s = a[i];
        reverse(a[i].begin(), a[i].end());
        if (a[i] != "") {
            if (a[i] == s) {
                s1 = a[i];
                break;
            }
        }
    }
    string ans = "";
 
    // Update the answer with
    // all strings of pair1
    for (int i = 0; i < r; i++) {
        ans = ans + pair1[i];
    }
    // Update the answer with
    // palindromic string s1
    if (s1 != "") {
        ans = ans + s1;
    }
    // Update the answer with
    // all strings of pair2
    for (int j = r - 1; j >= 0; j--) {
        ans = ans + pair2[j];
    }
    cout << ans << endl;
}
 
// Driver Code
int main()
{
    string a1[2] = { "aba", "aba" };
    int n1 = sizeof(a1) / sizeof(a1[0]);
    longestPalindrome(a1, n1);
 
    string a2[5] = { "abc", "dba", "kop",
                     "abd", "cba" };
    int n2 = sizeof(a2) / sizeof(a2[0]);
    longestPalindrome(a2, n2);
}
Java



// Java implementation to find the longest
// palindromic String formed using
// concatenation of given Strings in any order
class GFG
{
 
// Function to find the longest palindromic
// from given array of Strings
static void longestPalindrome(String a[],
                            int n)
{
    String []pair1 = new String[n];
    String []pair2 = new String[n];
    int r = 0;
 
    // Loop to find the pair of Strings
    // which are reverse of each other
    for (int i = 0; i < n; i++)
    {
        String s = a[i];
        s = reverse(s);
        for (int j = i + 1; j < n; j++)
        {
            if (a[i] != "" && a[j] != "")
            {
                if (s.equals(a[j]))
                {
                    pair1[r] = a[i];
                    pair2[r++] = a[j];
                    a[i] = "";
                    a[j] = "";
                    break;
                }
            }
        }
    }
    String s1 = "";
 
    // Loop to find if any palindromic
    // String is still left in the array
    for (int i = 0; i < n; i++)
    {
        String s = a[i];
        a[i] = reverse(a[i]);
        if (a[i] != "")
        {
            if (a[i].equals(s))
            {
                s1 = a[i];
                break;
            }
        }
    }
    String ans = "";
 
    // Update the answer with
    // all Strings of pair1
    for (int i = 0; i < r; i++)
    {
        ans = ans + pair1[i];
    }
     
    // Update the answer with
    // palindromic String s1
    if (s1 != "")
    {
        ans = ans + s1;
    }
    // Update the answer with
    // all Strings of pair2
    for (int j = r - 1; j >= 0; j--)
    {
        ans = ans + pair2[j];
    }
    System.out.print(ans +"\n");
}
static String reverse(String input)
{
    char[] a = input.toCharArray();
    int l, r = a.length - 1;
    for (l = 0; l < r; l++, r--)
    {
        char temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }
    return String.valueOf(a);
}
 
// Driver Code
public static void main(String[] args)
{
    String []a1 = { "aba", "aba" };
    int n1 = a1.length;
    longestPalindrome(a1, n1);
 
    String []a2 = { "abc", "dba", "kop",
                    "abd", "cba" };
    int n2 = a2.length;
    longestPalindrome(a2, n2);
}
}
 
// This code is contributed by Rajput-Ji
Python3



# Python3 implementation to find the longest
# palindromic String formed using
# concatenation of given strings in any order
 
# Function to find the longest palindromic
# from given array of strings
def longestPalindrome(a, n):
    pair1 = [0]*n
    pair2 = [0]*n
    r = 0
 
    # Loop to find the pair of strings
    # which are reverse of each other
    for i in range(n):
        s = a[i]
        s = s[::-1]
        for j in range(i + 1, n):
            if (a[i] != "" and a[j] != ""):
                if (s == a[j]):
                    pair1[r] = a[i]
                    pair2[r] = a[j]
                    r += 1
                    a[i] = ""
                    a[j] = ""
                    break
 
    s1 = ""
 
    # Loop to find if any palindromic
    # is still left in the array
    for i in range(n):
        s = a[i]
        a[i] = a[i][::-1]
        if (a[i] != ""):
            if (a[i] == s):
                s1 = a[i]
                break
 
    ans = ""
 
    # Update the answer with
    # all strings of pair1
    for i in range(r):
        ans = ans + pair1[i]
     
    # Update the answer with
    # palindromic s1
    if (s1 != ""):
        ans = ans + s1
     
    # Update the answer with
    # all strings of pair2
    for j in range(r - 1, -1, -1):
        ans = ans + pair2[j]
    print(ans)
 
# Driver Code
a1 = ["aba", "aba"]
n1 = len(a1)
longestPalindrome(a1, n1)
 
a2 = ["abc", "dba", "kop","abd", "cba"]
n2 = len(a2)
longestPalindrome(a2, n2)
 
# This code is contributed by mohit kumar 29
C#



// C# implementation to find the longest
// palindromic String formed using
// concatenation of given Strings in any order
using System;
 
class GFG
{
  
// Function to find the longest palindromic
// from given array of Strings
static void longestPalindrome(String []a,
                            int n)
{
    String []pair1 = new String[n];
    String []pair2 = new String[n];
    int r = 0;
  
    // Loop to find the pair of Strings
    // which are reverse of each other
    for (int i = 0; i < n; i++)
    {
        String s = a[i];
        s = reverse(s);
        for (int j = i + 1; j < n; j++)
        {
            if (a[i] != "" && a[j] != "")
            {
                if (s.Equals(a[j]))
                {
                    pair1[r] = a[i];
                    pair2[r++] = a[j];
                    a[i] = "";
                    a[j] = "";
                    break;
                }
            }
        }
    }
    String s1 = "";
  
    // Loop to find if any palindromic
    // String is still left in the array
    for (int i = 0; i < n; i++)
    {
        String s = a[i];
        a[i] = reverse(a[i]);
        if (a[i] != "")
        {
            if (a[i].Equals(s))
            {
                s1 = a[i];
                break;
            }
        }
    }
    String ans = "";
  
    // Update the answer with
    // all Strings of pair1
    for (int i = 0; i < r; i++)
    {
        ans = ans + pair1[i];
    }
      
    // Update the answer with
    // palindromic String s1
    if (s1 != "")
    {
        ans = ans + s1;
    }
    // Update the answer with
    // all Strings of pair2
    for (int j = r - 1; j >= 0; j--)
    {
        ans = ans + pair2[j];
    }
    Console.Write(ans +"\n");
}
static String reverse(String input)
{
    char[] a = input.ToCharArray();
    int l, r = a.Length - 1;
    for (l = 0; l < r; l++, r--)
    {
        char temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }
    return String.Join("",a);
}
  
// Driver Code
public static void Main(String[] args)
{
    String []a1 = { "aba", "aba" };
    int n1 = a1.Length;
    longestPalindrome(a1, n1);
  
    String []a2 = { "abc", "dba", "kop",
                    "abd", "cba" };
    int n2 = a2.Length;
    longestPalindrome(a2, n2);
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// Javascript implementation to find the longest
// palindromic String formed using
// concatenation of given strings in any order
 
// Function to find the longest palindromic
// from given array of strings
function longestPalindrome(a, n)
{
    var pair1 = Array(n);
    var pair2 = Array(n);
    var r = 0;
 
    // Loop to find the pair of strings
    // which are reverse of each other
    for(var i = 0; i < n; i++)
    {
        var s = a[i];
        s = s.split('').reverse().join('');
     
        for(var j = i + 1; j < n; j++)
        {
            if (a[i] != "" && a[j] != "")
            {
                if (s == a[j])
                {
                    pair1[r] = a[i];
                    pair2[r++] = a[j];
                    a[i] = "";
                    a[j] = "";
                    break;
                }
            }
        }
    }
    var s1 = "";
 
    // Loop to find if any palindromic
    // string is still left in the array
    for(var i = 0; i < n; i++)
    {
        var s = a[i];
        a[i] = a[i].split('').reverse().join('');
     
        if (a[i] != "")
        {
            if (a[i] == s)
            {
                s1 = a[i];
                break;
            }
        }
    }
    var ans = "";
 
    // Update the answer with
    // all strings of pair1
    for(var i = 0; i < r; i++)
    {
        ans = ans + pair1[i];
    }
     
    // Update the answer with
    // palindromic string s1
    if (s1 != "")
    {
        ans = ans + s1;
    }
     
    // Update the answer with
    // all strings of pair2
    for(var j = r - 1; j >= 0; j--)
    {
        ans = ans + pair2[j];
    }
    document.write(ans + "<br>");
}
 
// Driver Code
var a1 = [ "aba", "aba" ];
var n1 = a1.length;
longestPalindrome(a1, n1);
 
var a2 = [ "abc", "dba", "kop",
           "abd", "cba" ];
var n2 = a2.length;
longestPalindrome(a2, n2);
 
// This code is contributed by rrrtnx
 
</script>
Output: 
abaaba
abcdbaabdcba
 

My Personal Notes
arrow_drop_up
Previous
Python | Even Front digits Test in List
Next

DARQ – Technology Powerhouse of Future
Recommended Articles
Page :
Longest palindromic string formed by concatenation of prefix and suffix of a string
06, May 20
Print all possible palindromic string formed using any pair of given strings
09, Jul 20
Count of pairs of strings whose concatenation forms a palindromic string
16, Jul 20
Minimum characters to be replaced to make a string concatenation of a K-length palindromic string
19, Nov 20
Check if a Regular Bracket Sequence can be formed with concatenation of given strings
20, Sep 21
Check if given string is a substring of string formed by repeated concatenation of z to a
22, Jul 20
Longest Palindromic Substring using Palindromic Tree | Set 3
18, Apr 18
Check if K palindromic strings can be formed from a given string
04, Jun 20
Check if a Palindromic String can be formed by concatenating Substrings of two given Strings
23, Jul 20
Rearrange characters of a string to make it a concatenation of palindromic substrings
17, Mar 21
Longest palindromic string possible by concatenating strings from a given array
14, Oct 20
Minimum cuts required to convert a palindromic string to a different palindromic string
12, Mar 19
Maximum length of string formed by concatenation having even frequency of each character
12, Oct 21
All possible strings of any length that can be formed from a given string
15, May 17
Check if 2 * K + 1 non-empty strings exists whose concatenation forms the given string
26, Apr 21
Check if concatenation of any permutation of given list of arrays generates the given array
28, Sep 20
Make palindromic string non-palindromic by rearranging its letters
29, Jan 19
Distinct palindromic sub-strings of the given string using Dynamic Programming
15, May 19
Palindromic strings of length 3 possible by using characters of a given string
17, Jun 21
Strings formed from given characters without any consecutive repeating characters
18, Mar 20
Print all the palindromic permutations of given string in alphabetic order
01, Jan 18
Sort an array of strings in ascending order with each string sorted in descending order
18, Jan 21
Partition a string into palindromic strings of at least length 2 with every character present in a single string
23, Mar 21
Difference between concatenation of strings using (str += s) and (str = str + s)
11, Jan 22
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
AmanGupta65
@AmanGupta65
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!