GFG App
Open App
Browser
Continue

# Minimum number of deletions to make a string palindrome

Given a string of size ‘n’. The task is to remove or delete the minimum number of characters from the string so that the resultant string is a palindrome.

Note: The order of characters should be maintained.

Examples :

```Input : aebcbda
Output : 2
Remove characters 'e' and 'd'
Resultant string will be 'abcba'
which is a palindromic string

Input : geeksforgeeks
Output : 8```
Recommended Practice

A simple solution is to remove all subsequences one by one and check if the remaining string is palindrome or not. The time complexity of this solution is exponential.

• Take two indexes first as ‘i’ and last as a ‘j’
• Compare the character at the index ‘i’ and ‘j’
• If characters are equal, then
• Recursively call the function by incrementing ‘i’ by ‘1’ and decrementing ‘j’ by ‘1’
• else
• Recursively call the two functions, the first increment ‘i’ by ‘1’ keeping ‘j’ constant, second decrement ‘j’ by ‘1’ keeping ‘i’ constant.
• Take a minimum of both and return by adding ‘1’

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach` `#include ` `using` `namespace` `std;`   `// Function to return minimum` `// Element between two values` `int` `min(``int` `x, ``int` `y) ` `{ ` `  ``return` `(x < y) ? x : y; ` `}`   `// Utility function for calculating` `// Minimum element to delete` `int` `utility_fun_for_del(string str, ` `                          ``int` `i, ``int` `j)` `{` `    ``if` `(i >= j)` `        ``return` `0;`   `    ``// Condition to compare characters` `    ``if` `(str[i] == str[j]) ` `    ``{`   `        ``// Recursive function call` `        ``return` `utility_fun_for_del(str, ` `                                  ``i + 1, j - 1);` `    ``}`   `    ``// Return value, incrementing by 1` `    ``return` `1 + min(utility_fun_for_del(str, i + 1, j),` `                 ``utility_fun_for_del(str, i, j - 1));` `}`   `// Function to calculate the minimum` `// Element required to delete for` `// Making string palindrome` `int` `min_ele_del(string str)` `{`   `    ``// Utility function call` `    ``return` `utility_fun_for_del(str, 0, ` `                               ``str.length() - 1);` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"abefbac"``;` `    ``cout << ``"Minimum element of deletions = "` `         ``<< min_ele_del(str) << endl;` `    ``return` `0;` `}`   `// This code is contributed by MOHAMMAD MUDASSIR`

## Java

 `// Java program for above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to return minimum` `// Element between two values` `public` `static` `int` `min(``int` `x, ``int` `y) ` `{ ` `    ``return` `(x < y) ? x : y; ` `}` ` `  `// Utility function for calculating` `// Minimum element to delete` `public` `static` `int` `utility_fun_for_del(String str, ` `                                      ``int` `i, ``int` `j)` `{` `    ``if` `(i >= j)` `        ``return` `0``;` ` `  `    ``// Condition to compare characters` `    ``if` `(str.charAt(i) == str.charAt(j)) ` `    ``{` `        `  `        ``// Recursive function call` `        ``return` `utility_fun_for_del(str, ` `                                   ``i + ``1``, j - ``1``);` `    ``}` ` `  `    ``// Return value, incrementing by 1` `    ``return` `1` `+ Math.min(utility_fun_for_del(str, i + ``1``, j),` `                        ``utility_fun_for_del(str, i, j - ``1``));` `}` ` `  `// Function to calculate the minimum` `// Element required to delete for` `// Making string palindrome` `public` `static` `int` `min_ele_del(String str)` `{` `    `  `    ``// Utility function call` `    ``return` `utility_fun_for_del(str, ``0``, ` `                               ``str.length() - ``1``);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) ` `{` `    ``String str = ``"abefbac"``;` `    `  `    ``System.out.println(``"Minimum element of deletions = "` `+` `                       ``min_ele_del(str));` `}` `}`   `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program for above approach`   `# Utility function for calculating` `# Minimum element to delete` `def` `utility_fun_for_del(``Str``, i, j):` `    `  `    ``if` `(i >``=` `j):` `        ``return` `0`   `    ``# Condition to compare characters` `    ``if` `(``Str``[i] ``=``=` `Str``[j]):` `        `  `        ``# Recursive function call` `        ``return` `utility_fun_for_del(``Str``, i ``+` `1``, ` `                                        ``j ``-` `1``)`   `    ``# Return value, incrementing by 1` `    ``# return minimum Element between two values    ` `    ``return` `(``1` `+` `min``(utility_fun_for_del(``Str``, i ``+` `1``, j),` `                    ``utility_fun_for_del(``Str``, i, j ``-` `1``)))`   `# Function to calculate the minimum` `# Element required to delete for` `# Making string palindrome` `def` `min_ele_del(``Str``):`   `    ``# Utility function call` `    ``return` `utility_fun_for_del(``Str``, ``0``, ` `                           ``len``(``Str``) ``-` `1``)`   `# Driver code` `Str` `=` `"abefbac"`   `print``(``"Minimum element of deletions ="``,` `       ``min_ele_del(``Str``))`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program for above approach` `using` `System;` `using` `System.Collections.Generic; `   `class` `GFG{` `    `  `// Function to return minimum` `// Element between two values` `static` `int` `min(``int` `x, ``int` `y) ` `{ ` `    ``return` `(x < y) ? x : y; ` `}` `  `  `// Utility function for calculating` `// Minimum element to delete` `static` `int` `utility_fun_for_del(``string` `str, ` `                               ``int` `i, ``int` `j)` `{` `    ``if` `(i >= j)` `        ``return` `0;` `        `  `    ``// Condition to compare characters` `    ``if` `(str[i] == str[j]) ` `    ``{` `        `  `        ``// Recursive function call` `        ``return` `utility_fun_for_del(str, i + 1,` `                                        ``j - 1);` `    ``}` `  `  `    ``// Return value, incrementing by 1` `    ``return` `1 + Math.Min(utility_fun_for_del(` `                          ``str, i + 1, j),` `                        ``utility_fun_for_del(` `                          ``str, i, j - 1));` `}` `  `  `// Function to calculate the minimum` `// Element required to delete for` `// Making string palindrome` `static` `int` `min_ele_del(``string` `str)` `{` `    `  `    ``// Utility function call` `    ``return` `utility_fun_for_del(str, 0, ` `                               ``str.Length - 1);` `}`   `// Driver code    ` `static` `void` `Main() ` `{` `    ``string` `str = ``"abefbac"``;` ` `  `    ``Console.WriteLine(``"Minimum element of "` `+ ` `                      ``"deletions = "` `+` `                      ``min_ele_del(str));` `}` `}`   `// This code is contributed by divyesh072019`

## Javascript

 ``

Output

`Minimum element of deletions = 2`

Time complexity: O(2^n), the time complexity of this solution is exponential as it requires a recursive approach to solve the problem. There are two recursive calls in each step and hence the time complexity is O(2^n).
Auxiliary Space: O(n), the space complexity of this solution is linear as the recursive calls are stored in the stack frames and the maximum depth of the recursion tree can be n.

Approach: Top-down dynamic programming

Below is the implementation:

## C++

 `#include` `using` `namespace` `std;`   `int` `dp[2000][2000];`   `// Function definition` `int` `transformation(string s1, string s2,` `                   ``int` `i, ``int` `j)` `{` `    `  `    ``// Base cases` `    ``if` `(i >= (s1.size()) || j >= (s2.size()))` `        ``return` `0;` `    `  `    ``// Checking the desired condition` `    ``if` `(s1[i] == s2[j])` `    ``{` `        `  `        ``// If yes increment the count` `        ``dp[i][j] = 1 + transformation(s1, s2, i + 1,` `                                              ``j + 1);` `    ``}` `    `  `    ``// If no    ` `    ``if` `(dp[i][j] != -1) ` `    ``{` `        `  `        ``// Return the value from the table` `        ``return` `dp[i][j];` `    ``}` `    `  `    ``// Else store the max transformation` `    ``// from the subsequence` `    ``else` `        ``dp[i][j] = max(transformation(s1, s2, i, j + i),` `                       ``transformation(s1, s2, i + 1, j));` `    `  `    ``// Return the dp [-1][-1]    ` `    ``return` `dp[s1.size() - 1][s2.size() - 1];` `}`   `// Driver code` `int` `main()` `{` `    ``string s1 = ``"geeksforgeeks"``;` `    ``string s2 = ``"geeks"``;` `    ``int` `i = 0;` `    ``int` `j = 0;` `    `  `    ``// Initialize the array with -1` `    ``memset``(dp, -1, ``sizeof` `dp);` `    `  `    ``cout << ``"MINIMUM NUMBER OF DELETIONS: "` `         ``<< (s1.size()) - transformation(s1, s2, 0, 0)` `         ``<< endl;` `    ``cout << ``"MINIMUM NUMBER OF INSERTIONS: "` `         ``<< (s2.size()) - transformation(s1, s2, 0, 0)` `         ``<< endl;` `    ``cout << (``"LCS LENGTH: "``)` `         ``<< transformation(s1, s2, 0, 0);` `}`   `// This code is contributed by Stream_Cipher`

## Java

 `import` `java.util.*;` `public` `class` `GFG` `{` `    ``static` `int` `dp[][] = ``new` `int``[``2000``][``2000``];` `  `  `    ``// Function definition ` `    ``public` `static` `int` `transformation(String s1, ` `                                     ``String s2, ` `                                     ``int` `i, ``int` `j)` `    ``{` `      `  `        ``// Base cases` `        ``if``(i >= s1.length() || j >= s2.length())` `        ``{` `            ``return` `0``;` `        ``}` `        `  `        ``// Checking the desired condition` `        ``if``(s1.charAt(i) == s2.charAt(j))` `        ``{` `          `  `            ``// If yes increment the count` `            ``dp[i][j] = ``1` `+ transformation(s1, s2, i + ``1``, j + ``1``);` `        ``}` `        `  `        ``// If no  ` `        ``if``(dp[i][j] != -``1``)` `        ``{` `          `  `            ``// Return the value from the table` `            ``return` `dp[i][j];` `        ``}` `      `  `        ``// Else store the max transformation` `        ``// from the subsequence` `        ``else` `        ``{` `            ``dp[i][j] = Math.max(transformation(s1, s2, i, j + i), ` `                                ``transformation(s1, s2, i + ``1``, j));` `        ``}` `        `  `        ``// Return the dp [-1][-1]    ` `        ``return` `dp[s1.length() - ``1``][s2.length() - ``1``]; ` `    ``}` `    `  `    ``// Driver code` `     ``public` `static` `void` `main(String []args)` `     ``{` `        ``String s1 = ``"geeksforgeeks"``;` `        ``String s2 = ``"geeks"``;` `        ``int` `i = ``0``;` `        ``int` `j = ``0``;` `        `  `        ``// Initialize the array with -1` `        ``for` `(``int``[] row: dp)` `        ``{Arrays.fill(row, -``1``);}` `        `  `        ``System.out.println(``"MINIMUM NUMBER OF DELETIONS: "` `+` `                           ``(s1.length() - transformation(s1, s2, ``0``, ``0``)));` `        ``System.out.println(``"MINIMUM NUMBER OF INSERTIONS: "` `+` `                           ``(s2.length() - transformation(s1, s2, ``0``, ``0``)));` `        ``System.out.println(``"LCS LENGTH: "` `+ ` `                           ``transformation(s1, s2, ``0``, ``0``));` `     ``}` `}`   `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# function definition` `def` `transformation(s1,s2,i,j,dp): ` `    `  `     ``# base cases` `    ``if` `i>``=``len``(s1) ``or` `j>``=``len``(s2):` `        ``return` `0` `    `  `    ``# checking the desired condition` `    ``if` `s1[i]``=``=``s2[j]: ` `        `  `        ``# if yes increment the count` `        ``dp[i][j]``=``1``+``transformation(s1,s2,i``+``1``,j``+``1``,dp) ` `        `  `    ``# if no    ` `    ``if` `dp[i][j]!``=``-``1``: ` `        `  `        ``#return the value from the table` `        ``return` `dp[i][j] ` `    `  `    ``# else store the max transformation` `    ``# from the subsequence` `    ``else``: ` `        ``dp[i][j]``=``max``(transformation(s1,s2,i,j``+``i,dp),` `                     ``transformation(s1,s2,i``+``1``,j,dp))` `        `  `    ``# return the dp [-1][-1]    ` `    ``return` `dp[``-``1``][``-``1``] `   `                     `    `s1 ``=` `"geeksforgeeks"` `s2 ``=` `"geeks"` `i``=``0` `j``=``0`   `#initialize the array with -1` `dp``=``[[``-``1` `for` `_ ``in` `range``(``len``(s1)``+``1``)] ``for` `_ ``in` `range``(``len``(s2)``+``1``)] ` `print``(``"MINIMUM NUMBER OF DELETIONS: "``,` `      ``len``(s1)``-``transformation(s1,s2,``0``,``0``,dp),` `      ``end``=``" "``)` `print``(``"MINIMUM NUMBER OF INSERTIONS: "``,` `      ``len``(s2)``-``transformation(s1,s2,``0``,``0``,dp),` `      ``end``=``" "` `)` `print``(``"LCS LENGTH: "``,transformation(s1,s2,``0``,``0``,dp))`   `#code contributed by saikumar kudikala`

## C#

 `using` `System;`   `class` `GFG{` `    `  `static` `int``[,] dp = ``new` `int``[2000, 2000];`   `// Function definition ` `static` `int` `transformation(``string` `s1, ``string` `s2,` `                          ``int` `i, ``int` `j )` `{` `    `  `    ``// Base cases` `    ``if` `(i >= (s1.Length) || j >= (s2.Length))` `    ``{` `        ``return` `0;` `    ``}` `    `  `    ``// Checking the desired condition` `    ``if` `(s1[i] == s2[j])` `    ``{` `        `  `        ``// If yes increment the count` `        ``dp[i, j] = 1 + transformation(s1, s2, ` `                                      ``i + 1, j + 1);` `    ``}` `    `  `    ``// If no  ` `    ``if` `(dp[i, j] != -1)` `    ``{` `        `  `        ``// Return the value from the table` `        ``return` `dp[i, j];` `        `  `    ``}` `    `  `    ``// Else store the max transformation` `    ``// from the subsequence` `    ``else` `    ``{` `        ``dp[i, j] = Math.Max(transformation(s1, s2, i, ` `                                           ``j + i),` `                            ``transformation(s1, s2, ` `                                           ``i + 1, j));` `    ``}` `    `  `    ``// Return the dp [-1][-1]    ` `    ``return` `dp[s1.Length - 1, s2.Length - 1];` `}`   `// Driver code` `static` `public` `void` `Main()` `{` `    ``string` `s1 = ``"geeksforgeeks"``;` `    ``string` `s2 = ``"geeks"``;` `    `  `    ``// Initialize the array with -1` `    ``for``(``int` `m = 0; m < 2000; m++ )` `    ``{` `        ``for``(``int` `n = 0; n < 2000; n++)` `        ``{` `            ``dp[m, n] = -1;` `        ``}` `    ``}` `    ``Console.WriteLine(``"MINIMUM NUMBER OF DELETIONS: "` `+` `       ``(s1.Length-transformation(s1, s2, 0, 0)));` `    ``Console.WriteLine(``"MINIMUM NUMBER OF INSERTIONS: "` `+` `       ``(s2.Length-transformation(s1, s2, 0, 0)));` `    ``Console.WriteLine(``"LCS LENGTH: "` `+ ` `       ``transformation(s1, s2, 0, 0));` `}` `}`   `// This code is contributed by rag2127`

## Javascript

 ``

Output:

`MINIMUM NUMBER OF DELETIONS:  8 MINIMUM NUMBER OF INSERTIONS:  0 LCS LENGTH:  5`

Time Complexity: O(N^K)
Auxiliary Space: O(2000*2000)

Efficient Approach: It uses the concept of finding the length of the longest palindromic subsequence of a given sequence.

Below is the implementation of the approach:

## C++

 `// C++ implementation to find ` `// minimum number of deletions` `// to make a string palindromic` `#include ` `using` `namespace` `std;`   `// Returns the length of ` `// the longest palindromic ` `// subsequence in 'str'` `int` `lps(string str)` `{` `    ``int` `n = str.size();`   `    ``// Create a table to store` `    ``// results of subproblems` `    ``int` `L[n][n];`   `    ``// Strings of length 1` `    ``// are palindrome of length 1` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``L[i][i] = 1;`   `    ``// Build the table. Note that ` `    ``// the lower diagonal values ` `    ``// of table are useless and ` `    ``// not filled in the process. ` `    ``// c1 is length of substring` `    ``for` `(``int` `cl = 2; cl <= n; cl++)` `    ``{` `        ``for` `(``int` `i = 0; ` `                 ``i < n - cl + 1; i++)` `        ``{` `            ``int` `j = i + cl - 1;` `            ``if` `(str[i] == str[j] &&` `                        ``cl == 2)` `                ``L[i][j] = 2;` `            ``else` `if` `(str[i] == str[j])` `                ``L[i][j] = L[i + 1][j - 1] + 2;` `            ``else` `                ``L[i][j] = max(L[i][j - 1], ` `                            ``L[i + 1][j]);` `        ``}` `    ``}`   `    ``// length of longest` `    ``// palindromic subseq` `    ``return` `L[0][n - 1];` `}`   `// function to calculate ` `// minimum number of deletions` `int` `minimumNumberOfDeletions(string str)` `{` `    ``int` `n = str.size();`   `    ``// Find longest palindromic ` `    ``// subsequence` `    ``int` `len = lps(str);`   `    ``// After removing characters ` `    ``// other than the lps, we ` `    ``// get palindrome.` `    ``return` `(n - len);` `}`   `// Driver Code` `int` `main()` `{` `    ``string str = ``"geeksforgeeks"``;` `    ``cout << ``"Minimum number of deletions = "` `         ``<< minimumNumberOfDeletions(str);` `    ``return` `0;` `}`

## Java

 `// Java implementation to ` `// find minimum number of ` `// deletions to make a ` `// string palindromic` `class` `GFG` `{` `    ``// Returns the length of` `    ``// the longest palindromic` `    ``// subsequence in 'str'` `    ``static` `int` `lps(String str)` `    ``{` `        ``int` `n = str.length();`   `        ``// Create a table to store` `        ``// results of subproblems` `        ``int` `L[][] = ``new` `int``[n][n];`   `        ``// Strings of length 1` `        ``// are palindrome of length 1` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``L[i][i] = ``1``;`   `        ``// Build the table. Note ` `        ``// that the lower diagonal ` `        ``// values of table are useless ` `        ``// and not filled in the process.` `        ``// c1 is length of substring` `        ``for` `(``int` `cl = ``2``; cl <= n; cl++)` `        ``{` `            ``for` `(``int` `i = ``0``; i < n - cl + ``1``; i++)` `            ``{` `                ``int` `j = i + cl - ``1``;` `                ``if` `(str.charAt(i) == ` `                        ``str.charAt(j) && cl == ``2``)` `                    ``L[i][j] = ``2``;` `                ``else` `if` `(str.charAt(i) == ` `                              ``str.charAt(j))` `                    ``L[i][j] = L[i + ``1``][j - ``1``] + ``2``;` `                ``else` `                    ``L[i][j] = Integer.max(L[i][j - ``1``],` `                                         ``L[i + ``1``][j]);` `            ``}` `        ``}`   `        ``// length of longest ` `        ``// palindromic subsequence` `        ``return` `L[``0``][n - ``1``];` `    ``}`   `    ``// function to calculate minimum` `    ``// number of deletions` `    ``static` `int` `minimumNumberOfDeletions(String str)` `    ``{` `        ``int` `n = str.length();`   `        ``// Find longest palindromic` `        ``// subsequence` `        ``int` `len = lps(str);`   `        ``// After removing characters` `        ``// other than the lps, we get` `        ``// palindrome.` `        ``return` `(n - len);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``String str = ``"geeksforgeeks"``;` `        ``System.out.println(``"Minimum number "` `+ ` `                            ``"of deletions = "``+ ` `               ``minimumNumberOfDeletions(str));` `    ``}` `}`   `// This code is contributed by Sumit Ghosh`

## Python3

 `# Python3 implementation to find ` `# minimum number of deletions` `# to make a string palindromic` ` `  `# Returns the length of ` `# the longest palindromic ` `# subsequence in 'str'` `def` `lps(``str``):` `    ``n ``=` `len``(``str``)` ` `  `    ``# Create a table to store` `    ``# results of subproblems` `    ``L ``=` `[[``0` `for` `x ``in` `range``(n)]``for` `y ``in` `range``(n)]` ` `  `    ``# Strings of length 1` `    ``# are palindrome of length 1` `    ``for` `i ``in` `range``(n):` `        ``L[i][i] ``=` `1` ` `  `    ``# Build the table. Note that ` `    ``# the lower diagonal values ` `    ``# of table are useless and ` `    ``# not filled in the process. ` `    ``# c1 is length of substring` `    ``for` `cl ``in` `range``( ``2``, n``+``1``):` `        ``for` `i ``in` `range``(n ``-` `cl ``+` `1``):` `            ``j ``=` `i ``+` `cl ``-` `1` `            ``if` `(``str``[i] ``=``=` `str``[j] ``and` `cl ``=``=` `2``):` `                ``L[i][j] ``=` `2` `            ``elif` `(``str``[i] ``=``=` `str``[j]):` `                ``L[i][j] ``=` `L[i ``+` `1``][j ``-` `1``] ``+` `2` `            ``else``:` `                ``L[i][j] ``=` `max``(L[i][j ``-` `1``],L[i ``+` `1``][j])` ` `  `    ``# length of longest` `    ``# palindromic subseq` `    ``return` `L[``0``][n ``-` `1``]` ` `  `# function to calculate ` `# minimum number of deletions` `def` `minimumNumberOfDeletions( ``str``):`   `    ``n ``=` `len``(``str``)` ` `  `    ``# Find longest palindromic ` `    ``# subsequence` `    ``l ``=` `lps(``str``)` ` `  `    ``# After removing characters ` `    ``# other than the lps, we ` `    ``# get palindrome.` `    ``return` `(n ``-` `l)` ` `  `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``str` `=` `"geeksforgeeks"` `    ``print``( ``"Minimum number of deletions = "` `         ``, minimumNumberOfDeletions(``str``))`

## C#

 `// C# implementation to find ` `// minimum number of deletions` `// to make a string palindromic` `using` `System;`   `class` `GFG` `{` `    ``// Returns the length of ` `    ``// the longest palindromic` `    ``// subsequence in 'str'` `    ``static` `int` `lps(String str)` `    ``{` `        ``int` `n = str.Length;`   `        ``// Create a table to store` `        ``// results of subproblems` `        ``int` `[,]L = ``new` `int``[n, n];`   `        ``// Strings of length 1` `        ``// are palindrome of length 1` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``L[i, i] = 1;`   `        ``// Build the table. Note ` `        ``// that the lower diagonal ` `        ``// values of table are useless ` `        ``// and not filled in the process.` `        ``// c1 is length of substring` `        ``for` `(``int` `cl = 2; cl <= n; cl++)` `        ``{` `            ``for` `(``int` `i = 0; i < n - cl + 1; i++)` `            ``{` `                ``int` `j = i + cl - 1;` `                ``if` `(str[i] == str[j] && cl == 2)` `                    ``L[i, j] = 2;` `                ``else` `if` `(str[i] == str[j])` `                    ``L[i, j] = L[i + 1, j - 1] + 2;` `                ``else` `                    ``L[i, j] = Math.Max(L[i, j - 1], ` `                                      ``L[i + 1, j]);` `            ``}` `        ``}`   `        ``// length of longest ` `        ``// palindromic subsequence` `        ``return` `L[0, n - 1];` `    ``}`   `    ``// function to calculate minimum` `    ``// number of deletions` `    ``static` `int` `minimumNumberOfDeletions(``string` `str)` `    ``{` `        ``int` `n = str.Length;`   `        ``// Find longest palindromic` `        ``// subsequence` `        ``int` `len = lps(str);`   `        ``// After removing characters ` `        ``// other than the lps, we get` `        ``// palindrome.` `        ``return` `(n - len);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``string` `str = ``"geeksforgeeks"``;` `        ``Console.Write(``"Minimum number of"` `+` `                          ``" deletions = "` `+ ` `            ``minimumNumberOfDeletions(str));` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output

`Minimum number of deletions = 8`

Time Complexity: O(n^2),as the LPS subproblem is solved using dynamic programming.
Auxiliary Space: O(n^2) as a 2D array of size nxn is used to store the subproblems.

Efficient Approach: Space optimization

In the previous approach, the current value dp[i][j] only depends upon the current and previous row values of DP. So to optimize the space complexity we use a single 1D array to store the computations.

Implementation:

## C++

 `// C++ implementation to find ` `// minimum number of deletions` `// to make a string palindromic`   `#include ` `using` `namespace` `std;`   `// Returns the length of ` `// the longest palindromic ` `// subsequence in 'str'` `int` `lps(string str)` `{` `    ``int` `n = str.size();` `    `  `    ``// array to store computation ` `    ``// of subproblems ` `    ``int` `L[n];` `    `  `    ``// iterate over subproblems to get the current ` `    ``// value from previous computation` `    ``for` `(``int` `i = n - 1; i >= 0; i--)` `    ``{   ` `        ``// to store previous values` `        ``int` `back_up = 0;` `        ``for` `(``int` `j = i; j < n; j++)` `        ``{` `            ``if` `(j == i)` `                ``L[j] = 1;` `            ``else` `if` `(str[i] == str[j])` `            ``{` `                ``int` `temp = L[j];` `                ``L[j] = back_up + 2;` `                ``back_up = temp;` `            ``}` `            ``else` `            ``{` `                ``back_up = L[j];` `                ``L[j] = max(L[j], L[j - 1]);` `            ``}` `        ``}` `    ``}` `    `  `    ``// return final answer` `    ``return` `L[n - 1];` `}` `    `  `// function to calculate ` `// minimum number of deletions` `int` `minimumNumberOfDeletions(string str)` `{`   `    ``int` `n = str.size();` `    `  `    ``// Find longest palindromic ` `    ``// subsequence` `    ``int` `len = lps(str);`   `    ``// After removing characters ` `    ``// other than the lps, we ` `    ``// get palindrome.` `    ``return` `(n - len);` `}`   `// Driver Code` `int` `main()` `{` `    ``string str = ``"geeksforgeeks"``;` `    ``cout << ``"Minimum number of deletions = "` `<< minimumNumberOfDeletions(str);` `    ``return` `0;` `}` `// -- by bhardwajji`

Output

`Minimum number of deletions = 8`

Time Complexity: O(n^2).
Auxiliary Space: O(n)

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.