Longest palindromic string possible by concatenating strings from a given array
Last Updated :
22 Jun, 2021
Given an array of strings S[] consisting of N distinct strings of length M. The task is to generate the longest possible palindromic string by concatenating some strings from the given array.
Examples:
Input: N = 4, M = 3, S[] = {"omg", "bbb", "ffd", "gmo"}
Output: omgbbbgmo
Explanation: Strings "omg" and "gmo" are reverse of each other and "bbb" is itself a palindrome. Therefore, concatenating "omg" + "bbb" + "gmo" generates the longest palindromic string "omgbbbgmo".
Input: N = 4, M = 3, s[]={"poy", "fgh", "hgf", "yop"}
Output: poyfghhgfyop
Approach: Follow the steps below to solve the problem:
- Initialize a Set and insert each string from the given array in the Set.
- Initialize two vectors left_ans and right_ans to keep track of palindromic strings obtained.
- Now, iterate over the array of strings and check if its reverse exists in the Set or not.
- If found to be true, insert one of the strings into left_ans and the other into right_ans and erase both the strings from the Set to avoid repetition.
- If a string is a palindrome and its pair does not exist in the Set, then that string needs to be appended to the middle of the resultant string.
- Print the resultant string.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
void max_len(string s[], int N, int M)
{
// Stores the distinct strings
// from the given array
unordered_set<string> set_str;
// Insert the strings into set
for (int i = 0; i < N; i++) {
set_str.insert(s[i]);
}
// Stores the left and right
// substrings of the given string
vector<string> left_ans, right_ans;
// Stores the middle substring
string mid;
// Traverse the array of strings
for (int i = 0; i < N; i++) {
string t = s[i];
// Reverse the current string
reverse(t.begin(), t.end());
// Checking if the string is
// itself a palindrome or not
if (t == s[i]) {
mid = t;
}
// Check if the reverse of the
// string is present or not
else if (set_str.find(t)
!= set_str.end()) {
// Append to the left substring
left_ans.push_back(s[i]);
// Append to the right substring
right_ans.push_back(t);
// Erase both the strings
// from the set
set_str.erase(s[i]);
set_str.erase(t);
}
}
// Print the left substring
for (auto x : left_ans) {
cout << x;
}
// Print the middle substring
cout << mid;
reverse(right_ans.begin(),
right_ans.end());
// Print the right substring
for (auto x : right_ans) {
cout << x;
}
}
// Driver Code
int main()
{
int N = 4, M = 3;
string s[] = { "omg", "bbb",
"ffd", "gmo" };
// Function Call
max_len(s, N, M);
return 0;
}
// Java program for the
// above approach
import java.util.*;
class GFG{
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);
}
static void max_len(String s[],
int N, int M)
{
// Stores the distinct Strings
// from the given array
HashSet<String> set_str =
new HashSet<>();
// Insert the Strings
// into set
for (int i = 0; i < N; i++)
{
set_str.add(s[i]);
}
// Stores the left and right
// subStrings of the given String
Vector<String> left_ans =
new Vector<>();
Vector<String> right_ans =
new Vector<>();
// Stores the middle
// subString
String mid = "";
// Traverse the array
// of Strings
for (int i = 0; i < N; i++)
{
String t = s[i];
// Reverse the current
// String
t = reverse(t);
// Checking if the String is
// itself a palindrome or not
if (t == s[i])
{
mid = t;
}
// Check if the reverse of the
// String is present or not
else if (set_str.contains(t))
{
// Append to the left
// subString
left_ans.add(s[i]);
// Append to the right
// subString
right_ans.add(t);
// Erase both the Strings
// from the set
set_str.remove(s[i]);
set_str.remove(t);
}
}
// Print the left subString
for (String x : left_ans)
{
System.out.print(x);
}
// Print the middle
// subString
System.out.print(mid);
Collections.reverse(right_ans);
// Print the right subString
for (String x : right_ans)
{
System.out.print(x);
}
}
// Driver Code
public static void main(String[] args)
{
int N = 4, M = 3;
String s[] = {"omg", "bbb",
"ffd", "gmo"};
// Function Call
max_len(s, N, M);
}
}
// This code is contributed by Rajput-Ji
# Python3 program for the above approach
def max_len(s, N, M):
# Stores the distinct strings
# from the given array
set_str = {}
# Insert the strings into set
for i in s:
set_str[i] = 1
# Stores the left and right
# substrings of the given string
left_ans, right_ans = [], []
# Stores the middle substring
mid = ""
# Traverse the array of strings
for i in range(N):
t = s[i]
# Reverse the current string
t = t[::-1]
# Checking if the is
# itself a palindrome or not
if (t == s[i]):
mid = t
# Check if the reverse of the
# is present or not
elif (t in set_str):
# Append to the left substring
left_ans.append(s[i])
# Append to the right substring
right_ans.append(t)
# Erase both the strings
# from the set
del set_str[s[i]]
del set_str[t]
# Print the left substring
for x in left_ans:
print(x, end = "")
# Print the middle substring
print(mid, end = "")
right_ans = right_ans[::-1]
# Print the right substring
for x in right_ans:
print(x, end = "")
# Driver Code
if __name__ == '__main__':
N = 4
M = 3
s = [ "omg", "bbb", "ffd", "gmo"]
# Function call
max_len(s, N, M)
# This code is contributed by mohit kumar 29
// C# program for the
// above approach
using System;
using System.Collections.Generic;
class GFG{
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);
}
static void max_len(String []s,
int N, int M)
{
// Stores the distinct Strings
// from the given array
HashSet<String> set_str =
new HashSet<String>();
// Insert the Strings
// into set
for (int i = 0; i < N; i++)
{
set_str.Add(s[i]);
}
// Stores the left and right
// subStrings of the given String
List<String> left_ans =
new List<String>();
List<String> right_ans =
new List<String>();
// Stores the middle
// subString
String mid = "";
// Traverse the array
// of Strings
for (int i = 0; i < N; i++)
{
String t = s[i];
// Reverse the current
// String
t = reverse(t);
// Checking if the String is
// itself a palindrome or not
if (t == s[i])
{
mid = t;
}
// Check if the reverse of the
// String is present or not
else if (set_str.Contains(t))
{
// Append to the left
// subString
left_ans.Add(s[i]);
// Append to the right
// subString
right_ans.Add(t);
// Erase both the Strings
// from the set
set_str.Remove(s[i]);
set_str.Remove(t);
}
}
// Print the left subString
foreach (String x in left_ans)
{
Console.Write(x);
}
// Print the middle
// subString
Console.Write(mid);
right_ans.Reverse();
// Print the right subString
foreach (String x in right_ans)
{
Console.Write(x);
}
}
// Driver Code
public static void Main(String[] args)
{
int N = 4, M = 3;
String []s = {"omg", "bbb",
"ffd", "gmo"};
// Function Call
max_len(s, N, M);
}
}
// This code is contributed by 29AjayKumar
<script>
// Javascript program for the
// above approach
function reverse(input)
{
let a = input.split("");
a.reverse();
return a.join("");
}
function max_len(s, N, M)
{
// Stores the distinct Strings
// from the given array
let set_str = new Set();
// Insert the Strings
// into set
for (let i = 0; i < N; i++)
{
set_str.add(s[i]);
}
// Stores the left and right
// subStrings of the given String
let left_ans = [];
let right_ans = [];
// Stores the middle
// subString
let mid = "";
// Traverse the array
// of Strings
for (let i = 0; i < N; i++)
{
let t = s[i];
// Reverse the current
// String
t = reverse(t);
// Checking if the String is
// itself a palindrome or not
if (t == s[i])
{
mid = t;
}
// Check if the reverse of the
// String is present or not
else if (set_str.has(t))
{
// Append to the left
// subString
left_ans.push(s[i]);
// Append to the right
// subString
right_ans.push(t);
// Erase both the Strings
// from the set
set_str.delete(s[i]);
set_str.delete(t);
}
}
// Print the left subString
for (let x=0;x< left_ans.length;x++)
{
document.write(left_ans[x]);
}
// Print the middle
// subString
document.write(mid);
(right_ans).reverse();
// Print the right subString
for (let x = 0; x < right_ans.length; x++)
{
document.write(right_ans[x]);
}
}
// Driver Code
let N = 4, M = 3;
let s=["omg", "bbb",
"ffd", "gmo"];
// Function Call
max_len(s, N, M);
// This code is contributed by patel2127
</script>
Output:
omgbbbgmo
Time Complexity: O(N * M)
Auxiliary Space: O(N * M)
Similar Reads
Longest palindromic string formed by concatenation of prefix and suffix of a string Given string str, the task is to find the longest palindromic substring formed by the concatenation of the prefix and suffix of the given string str. Examples: Input: str = "rombobinnimor" Output: rominnimor Explanation: The concatenation of string "rombob"(prefix) and "mor"(suffix) is "rombobmor" w
10 min read
Longest Palindrome in a String formed by concatenating its prefix and suffix Given a string str consisting of lowercase English letters, the task is to find the longest palindromic string T which satisfies the following condition: T = p + m + s where p and s are the prefix and the suffix of the given string str respectively and the string m is either the prefix or suffix of
13 min read
Largest palindromic string possible from given strings by rearranging the characters Given two strings S and P, the task is to find the largest palindrome possible string by choosing characters from the given strings S and P after rearranging the characters. Note: If many answers are possible, then find the lexicographically smallest T with maximum length. Examples: Input: S = "abad
13 min read
Longest palindrome formed by concatenating and reordering strings of equal length Given an array arr[] consisting of N strings of equal length M, the task is to create the longest palindrome by concatenating the strings. Reordering and discarding some strings from the given set of strings can also be done.Examples: Input: N = 3, arr[] = { "tab", "one", "bat" }, M = 3 Output: tabb
9 min read
Maximize length of the String by concatenating characters from an Array of Strings Find the largest possible string of distinct characters formed using a combination of given strings. Any given string has to be chosen completely or not to be chosen at all. Examples: Input: strings ="abcd", "efgh", "efgh" Output: 8Explanation: All possible combinations are {"", "abcd", "efgh", "abc
12 min read
All possible strings of any length that can be formed from a given string Given a string of distinct characters, print all possible strings of any length that can be formed from given string characters. Examples: Input: abcOutput: a b c abc ab ac bc bac bca cb ca ba cab cba acbInput: abcdOutput: a b ab ba c ac ca bc cb abc acb bac bca cab cba d ad da bd db abd adb bad bda
10 min read