Minimum number of Appends needed to make a string palindrome

Given a string s we need to tell minimum characters to be appended (insertion at end) to make a string palindrome. 
Examples: 
 

Input : s = "abede"
Output : 2
We can make string palindrome as "abedeba"
by adding ba at the end of the string.

Input : s = "aabb"
Output : 2
We can make string palindrome as"aabbaa"
by adding aa at the end of the string.



 

The solution can be achieved by removing characters from the beginning of the string one by one and checking if the string is palindrome or not. 
For Example, consider the above string, s = “abede”
We check if the string is palindrome or not. 
The result is false, then we remove the character from the beginning of string and now string becomes “bede”.
We check if the string is palindrome or not. The result is again false, then we remove the character from the beginning of string and now string becomes “ede”.
We check if the string is palindrome or not. The result is true, so the output becomes 2 which is the number of characters removed from the string. 
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to find minimum number of appends
// needed to make a string Palindrome
#include<stdio.h>
#include<string.h>
#include<stdbool.h>
  
// Checking if the string is palindrome or not
bool isPalindrome(char *str)
{
    int len = strlen(str);
  
    // single character is always palindrome
    if (len == 1)
        return true;
  
    // pointing to first character
    char *ptr1 = str;
  
    // pointing to last character
    char *ptr2 = str+len-1;
  
    while (ptr2 > ptr1)
    {
        if (*ptr1 != *ptr2)
            return false;
        ptr1++;
        ptr2--;
    }
  
    return true;
}
  
// Recursive function to count number of appends
int noOfAppends(char s[])
{
    if (isPalindrome(s))
        return 0;
  
    // Removing first character of string by
    // incrementing base address pointer.
    s++;
  
    return 1 + noOfAppends(s);
}
  
// Driver program to test above functions
int main()
{
    char s[] = "abede";
    printf("%d\n", noOfAppends(s));
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find minimum number of appends
// needed to make a string Palindrome
class GFG 
{
  
// Checking if the string is palindrome or not
static boolean isPalindrome(char []str)
{
    int len = str.length;
  
    // single character is always palindrome
    if (len == 1)
        return true;
  
    // pointing to first character
    char ptr1 = str[0];
  
    // pointing to last character
    char ptr2 = str[len-1];
  
    while (ptr2 > ptr1)
    {
        if (ptr1 != ptr2)
            return false;
        ptr1++;
        ptr2--;
    }
  
    return true;
}
  
// Recursive function to count number of appends
static int noOfAppends(String s)
{
    if (isPalindrome(s.toCharArray()))
        return 0;
  
    // Removing first character of string by
    // incrementing base address pointer.
    s=s.substring(1);
  
    return 1 + noOfAppends(s);
}
  
// Driver code
public static void main(String arr[])
{
    String s = "abede";
    System.out.printf("%d\n", noOfAppends(s));
}
}
  
// This code contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to find minimum number of appends
# needed to make a String Palindrome
  
# Checking if the String is palindrome or not
def isPalindrome(Str):
  
    Len = len(Str)
  
    # single character is always palindrome
    if (Len == 1):
        return True
  
    # pointing to first character
    ptr1 = 0
  
    # pointing to last character
    ptr2 = Len - 1
  
    while (ptr2 > ptr1):
  
        if (Str[ptr1] != Str[ptr2]):
            return False
        ptr1 += 1
        ptr2 -= 1
  
    return True
  
# Recursive function to count number of appends
def noOfAppends(s):
  
    if (isPalindrome(s)):
        return 0
  
    # Removing first character of String by
    # incrementing base address pointer.
    del s[0]
  
    return 1 + noOfAppends(s)
  
# Driver Code
se = "abede"
s = [i for i in se]
print(noOfAppends(s))
  
# This code is contributed by Mohit Kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find minimum number of appends 
// needed to make a string Palindrome 
using System;
  
class GFG 
  
// Checking if the string is palindrome or not 
static Boolean isPalindrome(char []str) 
    int len = str.Length; 
  
    // single character is always palindrome 
    if (len == 1) 
        return true
  
    // pointing to first character 
    char ptr1 = str[0]; 
  
    // pointing to last character 
    char ptr2 = str[len-1]; 
  
    while (ptr2 > ptr1) 
    
        if (ptr1 != ptr2) 
            return false
        ptr1++; 
        ptr2--; 
    
  
    return true
  
// Recursive function to count number of appends 
static int noOfAppends(String s) 
    if (isPalindrome(s.ToCharArray())) 
        return 0; 
  
    // Removing first character of string by 
    // incrementing base address pointer. 
    s=s.Substring(1); 
  
    return 1 + noOfAppends(s); 
  
// Driver code 
public static void Main(String []arr) 
    String s = "abede"
    Console.Write("{0}\n", noOfAppends(s)); 
  
// This code has been contributed by 29AjayKumar

chevron_right


Output

2

The above approach described and O(n**2) approach. 



Efficient Approach:

We also have an algorithm taking the help of Knuth Morris Pratt Algorithm which is O(n) Time Complexity.

The basic idea behind the approach is that we calculate the largest substring from the end can be calculated and the length of the string minus this value is the minimum number of appends. The logic is intuitive, we need not append the palindrome and only those which do not form the palindrome. To find this largest palindrome from the end, we reverse the string, calculate the dfa and reverse the string again(thus gaining back the original string) and finding the final state, which represents the number of matches of the string with the revered string and hence we get the largest substring that is a palindrome from the end, in O(n) time.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program for above approach
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;
  
// This class builds the dfa and 
// precomputes the state. 
// See KMP algorithm for explanation
class kmp_numeric
{
  private:
  int n;
  int**dfa;
  public:
  
  kmp_numeric(string &s)
  {
    n = s.length();
    int c = 256;
      
    // Create dfa
    dfa = new int*[n];
      
    // Iterate from 0 to n
    for(int i = 0; i < n; i++)
      dfa[i] = new int;
      
    int x = 0;
      
    // Iterate from 0 to n
    for(int i = 0; i < c; i++)
      dfa[0][i] = 0;
      
    // Initialise dfa[0][s[0]] = 1
    dfa[0][s[0]] =  1; 
      
    // Iterate i from 1 to n-1
    for(int i = 1; i < n; i++)
    {
        
      // Itearte j from 0 to c - 1
      for(int j = 0; j < c; j++)
      {
        dfa[i][j] = dfa[x][j];
      }
       
      dfa[i][s[i]] = i+1;
      x = dfa[x][s[i]];
    }
  }
  
  
  // This function finds the overlap 
  // between two strings,by 
  // changing the state.
  int longest_overlap(string &query)
  {
  
    // q1 is length of query
    int ql = query.length();
    int state = 0;
  
    // Iterate from 0 to q1 - 1
    for(int i = 0; i < ql; i++)
    {
      state = dfa[state][query[i]];
    }
    return state;
  }
};
  
int min_appends(string &s)
{
  
  // Reverse the string.
  reverse(s.begin(),s.end());
  
  // Build the DFA for the  
  // reversed String
  kmp_numeric kmp = s;
  
  // Get the original string back
  reverse(s.begin(),s.end());
  
  // Largest overlap in this case is the 
  // largest string from the end which 
  // is a palindrome.
  int ans = s.length()-kmp.
                  longest_overlap(s); 
  return ans;
}
  
// Driver Code
int main()
{
  string s = "deep"
  // Answer : 3
  
  string t = "sososososos"
  // Answer : 0
  
  cout<<min_appends(s)<<endl;
  cout<<min_appends(t)<<endl;
}

chevron_right


Output

3
0

Suggestion by: <strong> Pratik Priyadarsan </strong>

Related Article : 
Dynamic Programming | Set 28 (Minimum insertions to form a palindrome)
This article is contributed by Shubham Chaudhary. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

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

Article Tags :
Practice Tags :


15


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