Minimum size substring to be removed to make a given string palindromic

Given a string S, the task is to print the string after removing the minimum size substring such that S is a palindrome or not.

Examples:

Input: S = “pqrstsuvwrqp”
Output: pqrstsrqp
Explanation:
Removal of the substring “uvw” modifies S to a palindromic string.

Input: S = “geeksforskeeg”
Output: geeksfskeeg
Explanation:
Removal of substring “or” modifies S to a palindromic string.

Approach: The idea is to include maximum size prefix and suffix from the given string S whose concatenation forms a palindrome. Then, choose the maximum length prefix or suffix from the remaining string which is a palindrome in itself. Below is the illustration of the approach with the help of an image:



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program of the
// above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find palindromic
// prefix of maximum length
string palindromePrefix(string S)
{
    int n = S.size();
 
    // Finding palindromic prefix of
    // maximum length
    for (int i = n - 1; i >= 0; i--) {
        string curr = S.substr(0, i + 1);
 
        // Checking if curr substring
        // is palindrome or not.
        int l = 0, r = curr.size() - 1;
        bool is_palindrome = 1;
 
        while (l < r) {
            if (curr[l] != curr[r]) {
                is_palindrome = 0;
                break;
            }
 
            l++;
            r--;
        }
 
        // Condition to check if the
        // prefix is a palindrome
        if (is_palindrome)
            return curr;
    }
 
    // if no palindrome exist
    return "";
}
 
// Function to find the maximum size
// palindrome such that after removing
// minimum size substring
string maxPalindrome(string S)
{
    int n = S.size();
    if (n <= 1) {
        return S;
    }
 
    string pre = "", suff = "";
 
    // Finding prefix and suffix
    // of same length
    int i = 0, j = n - 1;
    while (S[i] == S[j] && i < j) {
        i++;
        j--;
    }
    // Matching the ranges
    i--;
    j++;
 
    pre = S.substr(0, i + 1);
    suff = S.substr(j);
 
    // It is possible that the whole
    // string is palindrome.
 
    // Case 1: Length is even and
    // whole string is palindrome
    if (j - i == 1) {
        return pre + suff;
    }
 
    // Case 2: Length is odd and
    // whole string is palindrome
    if (j - i == 2) {
        // Adding that mid character
        string mid_char = S.substr(i + 1, 1);
 
        return pre + mid_char + suff;
    }
 
    // Add prefix or suffix of the remaining
    // string or suffix, whichever is longer
    string rem_str
        = S.substr(i + 1, j - i - 1);
 
    string pre_of_rem_str
        = palindromePrefix(rem_str);
 
    // Reverse the remaining string to
    // find the palindromic suffix
    reverse(rem_str.begin(), rem_str.end());
    string suff_of_rem_str
        = palindromePrefix(rem_str);
 
    if (pre_of_rem_str.size()
        >= suff_of_rem_str.size()) {
        return pre + pre_of_rem_str + suff;
    }
    else {
        return pre + suff_of_rem_str + suff;
    }
}
 
// Driver Code
int main()
{
    string S = "geeksforskeeg";
    cout << maxPalindrome(S);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program of the
// above approach
import java.util.*;
 
class GFG{
 
// Function to find palindromic
// prefix of maximum length
static String palindromePrefix(String S)
{
    int n = S.length();
 
    // Finding palindromic prefix of
    // maximum length
    for(int i = n - 1; i >= 0; i--)
    {
        String curr = S.substring(0, i + 1);
 
        // Checking if curr subString
        // is palindrome or not.
        int l = 0, r = curr.length() - 1;
        boolean is_palindrome = true;
 
        while (l < r)
        {
            if (curr.charAt(l) != curr.charAt(r))
            {
                is_palindrome = false;
                break;
            }
            l++;
            r--;
        }
         
        // Condition to check if the
        // prefix is a palindrome
        if (is_palindrome)
            return curr;
    }
     
    // If no palindrome exist
    return "";
}
 
// Function to find the maximum size
// palindrome such that after removing
// minimum size subString
static String maxPalindrome(String S)
{
    int n = S.length();
    if (n <= 1)
    {
        return S;
    }
 
    String pre = "", suff = "";
 
    // Finding prefix and suffix
    // of same length
    int i = 0, j = n - 1;
    while (S.charAt(i) ==
           S.charAt(j) && i < j)
    {
        i++;
        j--;
    }
     
    // Matching the ranges
    i--;
    j++;
 
    pre = S.substring(0, i + 1);
    suff = S.substring(j);
 
    // It is possible that the whole
    // String is palindrome.
 
    // Case 1: Length is even and
    // whole String is palindrome
    if (j - i == 1)
    {
        return pre + suff;
    }
 
    // Case 2: Length is odd and
    // whole String is palindrome
    if (j - i == 2)
    {
         
        // Adding that mid character
        String mid_char = S.substring(i + 1,
                                      i + 2);
 
        return pre + mid_char + suff;
    }
 
    // Add prefix or suffix of the remaining
    // String or suffix, whichever is longer
    String rem_str = S.substring(i + 1, j);
 
    String pre_of_rem_str = palindromePrefix(rem_str);
 
    // Reverse the remaining String to
    // find the palindromic suffix
    rem_str = reverse(rem_str);
     
    String suff_of_rem_str = palindromePrefix(rem_str);
 
    if (pre_of_rem_str.length()    >=
       suff_of_rem_str.length())
    {
        return pre + pre_of_rem_str + suff;
    }
    else
    {
        return pre + suff_of_rem_str + suff;
    }
}
 
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 S = "geeksforskeeg";
     
    System.out.print(maxPalindrome(S));
}
}
 
// This code is contributed by Amit Katiyar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program of the
# above approach
 
# Function to find palindromic
# prefix of maximum length
def palindromePrefix(S):
 
    n = len(S)
 
    # Finding palindromic prefix
    # of maximum length
    for i in range(n - 1, -1, -1):
        curr = S[0 : i + 1]
 
        # Checking if curr substring
        # is palindrome or not.
        l = 0
        r = len(curr) - 1
        is_palindrome = 1
 
        while (l < r):
            if (curr[l] != curr[r]):
                is_palindrome = 0
                break
 
            l += 1
            r -= 1
 
        # Condition to check if the
        # prefix is a palindrome
        if (is_palindrome):
            return curr
 
    # if no palindrome exist
    return ""
 
# Function to find the maximum
# size palindrome such that
# after removing minimum size
# substring
def maxPalindrome(S):
 
    n = len(S)
    if (n <= 1):
        return S
 
    pre = ""
    suff = ""
 
    # Finding prefix and
    # suffix of same length
    i = 0
    j = n - 1
    while (S[i] == S[j] and
           i < j):
        i += 1
        j -= 1
 
    # Matching the ranges
    i -= 1
    j += 1
 
    pre = S[0 : i + 1]
    suff = S[j:]
 
    # It is possible that the
    # whole string is palindrome.
 
    # Case 1: Length is even and
    # whole string is palindrome
    if (j - i == 1):
        return pre + suff
 
    # Case 2: Length is odd and
    # whole string is palindrome
    if (j - i == 2):
       
        # Adding that mid character
        mid_char = S[i + 1 : i + 2]
 
        return pre + mid_char + suff
 
    # Add prefix or suffix of the
    # remaining string or suffix,
    # whichever is longer
    rem_str = S[i + 1 : j]
 
    pre_of_rem_str = palindromePrefix(rem_str)
 
    # Reverse the remaining string to
    # find the palindromic suffix
    list1 = list(rem_str)
 
    list1.reverse()
    rem_str = ''.join(list1)
    suff_of_rem_str = palindromePrefix(rem_str)
 
    if (len(pre_of_rem_str) >=
        len(suff_of_rem_str)):
        return (pre + pre_of_rem_str +
                suff)
    else:
        return (pre + suff_of_rem_str +
                suff)
       
# Driver Code
if __name__ == "__main__":
 
    S = "geeksforskeeg"
    print(maxPalindrome(S))
 
# This code is contributed by Chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program of the
// above approach
using System;
class GFG{
 
// Function to find palindromic
// prefix of maximum length
static String palindromePrefix(String S)
{
  int n = S.Length;
 
  // Finding palindromic prefix of
  // maximum length
  for(int i = n - 1; i >= 0; i--)
  {
    String curr = S.Substring(0, i + 1);
 
    // Checking if curr subString
    // is palindrome or not.
    int l = 0, r = curr.Length - 1;
    bool is_palindrome = true;
 
    while (l < r)
    {
      if (curr[l] != curr[r])
      {
        is_palindrome = false;
        break;
      }
      l++;
      r--;
    }
 
    // Condition to check if the
    // prefix is a palindrome
    if (is_palindrome)
      return curr;
  }
 
  // If no palindrome exist
  return "";
}
 
// Function to find the maximum size
// palindrome such that after removing
// minimum size subString
static String maxPalindrome(String S)
{
  int n = S.Length;
  if (n <= 1)
  {
    return S;
  }
 
  String pre = "", suff = "";
 
  // Finding prefix and suffix
  // of same length
  int i = 0, j = n - 1;
  while (S[i] == S[j] && i < j)
  {
    i++;
    j--;
  }
 
  // Matching the ranges
  i--;
  j++;
 
  pre = S.Substring(0, i + 1);
  suff = S.Substring(j);
 
  // It is possible that the whole
  // String is palindrome.
 
  // Case 1: Length is even and
  // whole String is palindrome
  if (j - i == 1)
  {
    return pre + suff;
  }
 
  // Case 2: Length is odd and
  // whole String is palindrome
  if (j - i == 2)
  {
 
    // Adding that mid character
    String mid_char = S.Substring(i + 1,
                                  i + 2);
 
    return pre + mid_char + suff;
  }
 
  // Add prefix or suffix of the remaining
  // String or suffix, whichever is longer
  String rem_str = S.Substring(i + 1, j);
 
  String pre_of_rem_str = palindromePrefix(rem_str);
 
  // Reverse the remaining String to
  // find the palindromic suffix
  rem_str = reverse(rem_str);
 
  String suff_of_rem_str = palindromePrefix(rem_str);
 
  if (pre_of_rem_str.Length >=
      suff_of_rem_str.Length)
  {
    return pre + pre_of_rem_str + suff;
  }
  else
  {
    return pre + suff_of_rem_str + suff;
  }
}
 
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 S = "geeksforskeeg";
  Console.Write(maxPalindrome(S));
}
}
 
// This code is contributed by shikhasingrajput

chevron_right


Output: 

geeksfskeeg





Time Complexity: O(N2
Auxiliary Space: O(N)

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.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.