# Longest Palindromic Substring

Given a string str, the task is to find the longest substring which is a palindrome.

Examples:

Input: str = “forgeeksskeegfor”
Output: “geeksskeeg”
Explanation: There are several possible palindromic substrings like “kssk”, “ss”, “eeksskee” etc. But the substring “geeksskeeg” is the longest among all.

Input: str = “Geeks”
Output: “ee”

### Naive Approach for Longest Palindromic Substring:

Check each substring, if it is a palindrome or not and keep updating the longest palindromic substring found till now.

Follow the steps mentioned below to implement the idea:

• Generate all the substrings.
• For each substring, check if it is palindrome or not.
• If substring is Palindrome, then update the result on the basis of longest palindromic substring found till now.

Below is the implementation of the above approach:

## C++

 `// A C++ solution for longest palindrome` `#include ``using` `namespace` `std;` `// Function to print a substring str[low..high]``void` `printSubStr(string str, ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``cout << str[i];``}` `// This function prints the longest palindrome substring``// It also returns the length of the longest palindrome``int` `longestPalSubstr(string str)``{``    ``// Get length of input string``    ``int` `n = str.size();` `    ``// All substrings of length 1 are palindromes``    ``int` `maxLength = 1, start = 0;` `    ``// Nested loop to mark start and end index``    ``for` `(``int` `i = 0; i < str.length(); i++) {``        ``for` `(``int` `j = i; j < str.length(); j++) {``            ``int` `flag = 1;` `            ``// Check palindrome``            ``for` `(``int` `k = 0; k < (j - i + 1) / 2; k++)``                ``if` `(str[i + k] != str[j - k])``                    ``flag = 0;` `            ``// Palindrome``            ``if` `(flag && (j - i + 1) > maxLength) {``                ``start = i;``                ``maxLength = j - i + 1;``            ``}``        ``}``    ``}` `    ``cout << ``"Longest palindrome substring is: "``;``    ``printSubStr(str, start, start + maxLength - 1);` `    ``// Return length of LPS``    ``return` `maxLength;``}` `// Driver Code``int` `main()``{``    ``string str = ``"forgeeksskeegfor"``;``    ``cout << ``"\nLength is: "` `<< longestPalSubstr(str);``    ``return` `0;``}`

## C

 `#include ``#include ` `// Function to print a substring str[low..high]``void` `printSubStr(``const` `char``* str, ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``printf``(``"%c"``, str[i]);``}` `// This function prints the longest palindrome substring``// It also returns the length of the longest palindrome``int` `longestPalSubstr(``const` `char``* str)``{``    ``// Get length of input string``    ``int` `n = ``strlen``(str);` `    ``// All substrings of length 1 are palindromes``    ``int` `maxLength = 1, start = 0;` `    ``// Nested loop to mark start and end index``    ``for` `(``int` `i = 0; i < n; i++) {``        ``for` `(``int` `j = i; j < n; j++) {``            ``int` `flag = 1;` `            ``// Check palindrome``            ``for` `(``int` `k = 0; k < (j - i + 1) / 2; k++)``                ``if` `(str[i + k] != str[j - k])``                    ``flag = 0;` `            ``// Palindrome``            ``if` `(flag && (j - i + 1) > maxLength) {``                ``start = i;``                ``maxLength = j - i + 1;``            ``}``        ``}``    ``}` `    ``printf``(``"Longest palindrome substring is: "``);``    ``printSubStr(str, start, start + maxLength - 1);``    ``printf``(``"\n"``);` `    ``// Return length of LPS``    ``return` `maxLength;``}` `// Driver Code``int` `main()``{``    ``const` `char``* str = ``"forgeeksskeegfor"``;``    ``printf``(``"Length is: %d\n"``, longestPalSubstr(str));``    ``return` `0;``}`

## Java

 `// A Java solution for longest palindrome` `import` `java.util.*;` `class` `GFG {` `    ``// Function to print a subString str[low..high]``    ``static` `void` `printSubStr(String str, ``int` `low, ``int` `high)``    ``{``        ``for` `(``int` `i = low; i <= high; ++i)``            ``System.out.print(str.charAt(i));``    ``}` `    ``// This function prints the``    ``// longest palindrome subString``    ``// It also returns the length``    ``// of the longest palindrome``    ``static` `int` `longestPalSubstr(String str)``    ``{``        ``// Get length of input String``        ``int` `n = str.length();` `        ``// All subStrings of length 1``        ``// are palindromes``        ``int` `maxLength = ``1``, start = ``0``;` `        ``// Nested loop to mark start and end index``        ``for` `(``int` `i = ``0``; i < str.length(); i++) {``            ``for` `(``int` `j = i; j < str.length(); j++) {``                ``int` `flag = ``1``;` `                ``// Check palindrome``                ``for` `(``int` `k = ``0``; k < (j - i + ``1``) / ``2``; k++)``                    ``if` `(str.charAt(i + k)``                        ``!= str.charAt(j - k))``                        ``flag = ``0``;` `                ``// Palindrome``                ``if` `(flag != ``0` `&& (j - i + ``1``) > maxLength) {``                    ``start = i;``                    ``maxLength = j - i + ``1``;``                ``}``            ``}``        ``}` `        ``System.out.print(``            ``"Longest palindrome substring is: "``);``        ``printSubStr(str, start, start + maxLength - ``1``);` `        ``// Return length of LPS``        ``return` `maxLength;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``"forgeeksskeegfor"``;``        ``System.out.print(``"\nLength is: "``                         ``+ longestPalSubstr(str));``    ``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# A Python3 solution for longest palindrome`  `# Function to print a subString str[low..high]``def` `printSubStr(``str``, low, high):``    ``for` `i ``in` `range``(low, high ``+` `1``):``        ``print``(``str``[i], end``=``"")`  `# This function prints the``# longest palindrome subString``# It also returns the length``# of the longest palindrome``def` `longestPalSubstr(``str``):` `    ``# Get length of input String``    ``n ``=` `len``(``str``)` `    ``# All subStrings of length 1``    ``# are palindromes``    ``maxLength ``=` `1``    ``start ``=` `0` `    ``# Nested loop to mark start``    ``# and end index``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i, n):``            ``flag ``=` `1` `            ``# Check palindrome``            ``for` `k ``in` `range``(``0``, ((j ``-` `i) ``/``/` `2``) ``+` `1``):``                ``if` `(``str``[i ``+` `k] !``=` `str``[j ``-` `k]):``                    ``flag ``=` `0` `            ``# Palindrome``            ``if` `(flag !``=` `0` `and` `(j ``-` `i ``+` `1``) > maxLength):``                ``start ``=` `i``                ``maxLength ``=` `j ``-` `i ``+` `1` `    ``print``(``"Longest palindrome substring is: "``, end``=``"")``    ``printSubStr(``str``, start, start ``+` `maxLength ``-` `1``)` `    ``# Return length of LPS``    ``return` `maxLength`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``str` `=` `"forgeeksskeegfor"``    ``print``(``"\nLength is:"``, longestPalSubstr(``str``))` `# This code is contributed by 29AjayKumar`

## C#

 `// A C# solution for longest palindrome``using` `System;` `class` `GFG {` `    ``// Function to print a subString str[low..high]``    ``static` `void` `printSubStr(String str, ``int` `low, ``int` `high)``    ``{``        ``for` `(``int` `i = low; i <= high; ++i)``            ``Console.Write(str[i]);``    ``}` `    ``// This function prints the``    ``// longest palindrome subString``    ``// It also returns the length``    ``// of the longest palindrome``    ``static` `int` `longestPalSubstr(String str)``    ``{``        ``// get length of input String``        ``int` `n = str.Length;` `        ``// All subStrings of length 1``        ``// are palindromes``        ``int` `maxLength = 1, start = 0;` `        ``// Nested loop to mark start and end index``        ``for` `(``int` `i = 0; i < str.Length; i++) {``            ``for` `(``int` `j = i; j < str.Length; j++) {``                ``int` `flag = 1;` `                ``// Check palindrome``                ``for` `(``int` `k = 0; k < (j - i + 1) / 2; k++)``                    ``if` `(str[i + k] != str[j - k])``                        ``flag = 0;` `                ``// Palindrome``                ``if` `(flag != 0 && (j - i + 1) > maxLength) {``                    ``start = i;``                    ``maxLength = j - i + 1;``                ``}``            ``}``        ``}` `        ``Console.Write(``"Longest palindrome substring is: "``);``        ``printSubStr(str, start, start + maxLength - 1);` `        ``// Return length of LPS``        ``return` `maxLength;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``String str = ``"forgeeksskeegfor"``;``        ``Console.Write(``"\nLength is: "``                      ``+ longestPalSubstr(str));``    ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 `// A Javascript solution for longest palindrome` `// Function to print a subString str[low..high]``function` `printSubStr(str,low,high)``{``    ``for` `(let i = low; i <= high; ++i)``        ``console.log(str[i]);``}` `// This function prints the``// longest palindrome subString``// It also returns the length``// of the longest palindrome``function` `longestPalSubstr(str)``{``    ``// Get length of input String``    ``let n = str.length;`` ` `    ``// All subStrings of length 1``    ``// are palindromes``    ``let maxLength = 1, start = 0;`` ` `    ``// Nested loop to mark start and end index``    ``for` `(let i = 0; i < str.length; i++) {``        ``for` `(let j = i; j < str.length; j++) {``            ``let flag = 1;`` ` `            ``// Check palindrome``            ``for` `(let k = 0; k < (j - i + 1) / 2; k++)``                ``if` `(str[i + k] != str[j - k])``                    ``flag = 0;`` ` `            ``// Palindrome``            ``if` `(flag!=0 && (j - i + 1) > maxLength) {``                ``start = i;``                ``maxLength = j - i + 1;``            ``}``        ``}``    ``}`` ` `    ``console.log(``"Longest palindrome substring is: "``);``    ``printSubStr(str, start, start + maxLength - 1);`` ` `    ``// Return length of LPS``    ``return` `maxLength;``}` `// Driver Code``let str = ``"forgeeksskeegfor"``;``console.log(``"Length is: "``         ``+ longestPalSubstr(str));` `// This code is contributed by rag2127`

Output
```Longest palindrome substring is: geeksskeeg
Length is: 10

```

Complexity Analysis:

• Time complexity: O(N3). Three nested loops are needed to find the longest palindromic substring in this approach.
• Auxiliary complexity: O(1). As no extra space is needed.

### Longest Palindromic Substring using Dynamic Programming:

The main idea behind the approach is that if we know the status (i.e., palindrome or not) of the substring ranging [i, j], we can find the status of the substring ranging [i-1, j+1] by only matching the character str[i-1] and str[j+1].

• If the substring from i to j is not a palindrome, then the substring from i-1 to j+1 will also not be a palindrome. Otherwise, it will be a palindrome only if str[i-1] and str[j+1] are the same.

Base on this fact, we can create a 2D table (say table[][] which stores status of substring str[i . . . j] ), and check for substrings with length from 1 to N. For each length find all the substrings starting from each character i and find if it is a palindrom or not using the above idea. The longest length for which a palindrome formed will be the required asnwer.

Illustration:

Follow the below illustration for a better understanding.

Consider the string “geeks“. Below is the structure of the table formed and from this, we can see that the longest substring is 2.

Table for the string “geeks”

Follow the steps mentioned below to implement the idea:

• Maintain a boolean table[N][N] that is filled in a bottom-up manner.
• Iterate for all possible lengths from 1 to N:
• For each length iterate from i = 0 to N-length:
• Find the end of the substring j = i+length-1.
• The value of table[i][j] is true, if the substring is palindrome, otherwise false.
• To calculate table[i][j], check the value of table[i+1][j-1]:
• if the value is true and str[i] is the same as str[j], then we make table[i][j] true.
• Otherwise, the value of table[i][j] is made false.
• We have to fill the table initially for substrings of length = 1 and length = 2.
• Update the longest palindrome accordingly whenever a new palindrome of greater length is found.

Below is the implementation of the above approach:

## C++

 `// A C++ dynamic programming``// solution for longest palindrome` `#include ``using` `namespace` `std;` `// Function to print a substring``// str[low..high]``void` `printSubStr(``    ``string str, ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``cout << str[i];``}` `// This function prints the``// longest palindrome substring``// It also returns the length of``// the longest palindrome``int` `longestPalSubstr(string str)``{``    ``// Get length of input string``    ``int` `n = str.size();` `    ``// table[i][j] will be false if substring``    ``// str[i..j] is not palindrome.``    ``// Else table[i][j] will be true``    ``bool` `table[n][n];` `    ``memset``(table, 0, ``sizeof``(table));` `    ``// All substrings of length 1``    ``// are palindromes``    ``int` `maxLength = 1;` `    ``for` `(``int` `i = 0; i < n; ++i)``        ``table[i][i] = ``true``;` `    ``// Check for sub-string of length 2.``    ``int` `start = 0;``    ``for` `(``int` `i = 0; i < n - 1; ++i) {``        ``if` `(str[i] == str[i + 1]) {``            ``table[i][i + 1] = ``true``;``            ``start = i;``            ``maxLength = 2;``        ``}``    ``}` `    ``// Check for lengths greater than 2.``    ``// k is length of substring``    ``for` `(``int` `k = 3; k <= n; ++k) {``        ` `        ``// Fix the starting index``        ``for` `(``int` `i = 0; i < n - k + 1; ++i) {``            ` `            ``// Get the ending index of substring from``            ``// starting index i and length k``            ``int` `j = i + k - 1;` `            ``// Checking for sub-string from ith index to``            ``// jth index if str[i+1] to str[j-1] is a``            ``// palindrome``            ``if` `(table[i + 1][j - 1] && str[i] == str[j]) {``                ``table[i][j] = ``true``;` `                ``if` `(k > maxLength) {``                    ``start = i;``                    ``maxLength = k;``                ``}``            ``}``        ``}``    ``}` `    ``cout << ``"Longest palindrome substring is: "``;``    ``printSubStr(str, start, start + maxLength - 1);` `    ``// Return length of LPS``    ``return` `maxLength;``}` `// Driver Code``int` `main()``{``    ``string str = ``"forgeeksskeegfor"``;``    ``cout << ``"\nLength is: "``         ``<< longestPalSubstr(str);``    ``return` `0;``}`

## C

 `#include ``#include ``#include ` `// Function to print a substring str[low..high]``void` `printSubStr(``const` `char``* str, ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``printf``(``"%c"``, str[i]);``}` `// This function prints the longest palindrome substring``// It also returns the length of the longest palindrome``int` `longestPalSubstr(``const` `char``* str)``{``    ``// Get length of input string``    ``int` `n = ``strlen``(str);` `    ``// table[i][j] will be false if substring str[i..j] is``    ``// not palindrome. Else table[i][j] will be true``    ``bool` `table[n][n];` `    ``memset``(table, ``false``, ``sizeof``(table));` `    ``// All substrings of length 1 are palindromes``    ``int` `maxLength = 1;``    ``int` `start = 0;` `    ``for` `(``int` `i = 0; i < n; ++i)``        ``table[i][i] = ``true``;` `    ``// Check for sub-string of length 2.``    ``for` `(``int` `i = 0; i < n - 1; ++i) {``        ``if` `(str[i] == str[i + 1]) {``            ``table[i][i + 1] = ``true``;``            ``start = i;``            ``maxLength = 2;``        ``}``    ``}` `    ``// Check for lengths greater than 2.``    ``for` `(``int` `k = 3; k <= n; ++k) {``        ``// Fix the starting index``        ``for` `(``int` `i = 0; i < n - k + 1; ++i) {``            ``// Get the ending index of substring from``            ``// starting index i and length k``            ``int` `j = i + k - 1;` `            ``// Checking for sub-string from ith index to jth``            ``// index if str[i+1] to str[j-1] is a palindrome``            ``if` `(table[i + 1][j - 1] && str[i] == str[j]) {``                ``table[i][j] = ``true``;` `                ``if` `(k > maxLength) {``                    ``start = i;``                    ``maxLength = k;``                ``}``            ``}``        ``}``    ``}` `    ``printf``(``"Longest palindrome substring is: "``);``    ``printSubStr(str, start, start + maxLength - 1);``    ``printf``(``"\n"``);` `    ``// Return length of LPS``    ``return` `maxLength;``}` `// Driver Code``int` `main()``{``    ``const` `char``* str = ``"forgeeksskeegfor"``;``    ``printf``(``"Length is: %d\n"``, longestPalSubstr(str));``    ``return` `0;``}`

## Java

 `// Java Solution` `public` `class` `LongestPalinSubstring {``    ` `    ``// A utility function to print``    ``// a substring str[low..high]``    ``static` `void` `printSubStr(``        ``String str, ``int` `low, ``int` `high)``    ``{``        ``System.out.println(``            ``str.substring(``                ``low, high + ``1``));``    ``}` `    ``// This function prints the longest``    ``// palindrome substring of str[].``    ``// It also returns the length of the``    ``// longest palindrome``    ``static` `int` `longestPalSubstr(String str)``    ``{``        ``// Get length of input string``        ``int` `n = str.length();` `        ``// table[i][j] will be false if``        ``// substring str[i..j] is not palindrome.``        ``// Else table[i][j] will be true``        ``boolean` `table[][] = ``new` `boolean``[n][n];` `        ``// All substrings of length 1 are palindromes``        ``int` `maxLength = ``1``;``        ``for` `(``int` `i = ``0``; i < n; ++i)``            ``table[i][i] = ``true``;` `        ``// Check for sub-string of length 2.``        ``int` `start = ``0``;``        ``for` `(``int` `i = ``0``; i < n - ``1``; ++i) {``            ``if` `(str.charAt(i) == str.charAt(i + ``1``)) {``                ``table[i][i + ``1``] = ``true``;``                ``start = i;``                ``maxLength = ``2``;``            ``}``        ``}` `        ``// Check for lengths greater than 2.``        ``// k is length of substring``        ``for` `(``int` `k = ``3``; k <= n; ++k) {` `            ``// Fix the starting index``            ``for` `(``int` `i = ``0``; i < n - k + ``1``; ++i) {``                ` `                ``// Get the ending index of substring from``                ``// starting index i and length k``                ``int` `j = i + k - ``1``;` `                ``// Checking for sub-string from ith index to``                ``// jth index if str.charAt(i+1) to``                ``// str.charAt(j-1) is a palindrome``                ``if` `(table[i + ``1``][j - ``1``]``                    ``&& str.charAt(i) == str.charAt(j)) {``                    ``table[i][j] = ``true``;` `                    ``if` `(k > maxLength) {``                        ``start = i;``                        ``maxLength = k;``                    ``}``                ``}``            ``}``        ``}``        ``System.out.print(``"Longest palindrome substring is: "``);``        ``printSubStr(str, start,``                    ``start + maxLength - ``1``);` `        ``// Return length of LPS``        ``return` `maxLength;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``"forgeeksskeegfor"``;``        ``System.out.println(``"Length is: "` `+ longestPalSubstr(str));``    ``}``}` `// This code is contributed by Sumit Ghosh`

## Python3

 `# Python program` `import` `sys`  `# A utility function to print a``# substring str[low..high]``def` `printSubStr(st, low, high):``    ``print` `((st[low: high ``+` `1``]))`  `# This function prints the longest palindrome``# substring of st[]. It also returns the length``# of the longest palindrome``def` `longestPalSubstr(st):` `    ``# Get length of input string``    ``n ``=` `len``(st)` `    ``# table[i][j] will be false if substring``    ``# str[i..j] is not palindrome. Else``    ``# table[i][j] will be true``    ``table ``=` `[[``0` `for` `x ``in` `range``(n)] ``for` `y``             ``in` `range``(n)]` `    ``# All substrings of length 1 are``    ``# palindromes``    ``maxLength ``=` `1``    ``i ``=` `0``    ``while` `(i < n):``        ``table[i][i] ``=` `True``        ``i ``=` `i ``+` `1` `    ``# Check for sub-string of length 2.``    ``start ``=` `0``    ``i ``=` `0``    ``while` `i < n ``-` `1``:``        ``if` `(st[i] ``=``=` `st[i ``+` `1``]):``            ``table[i][i ``+` `1``] ``=` `True``            ``start ``=` `i``            ``maxLength ``=` `2``        ``i ``=` `i ``+` `1` `    ``# Check for lengths greater than 2.``    ``# k is length of substring``    ``k ``=` `3``    ``while` `k <``=` `n:` `        ``# Fix the starting index``        ``i ``=` `0``        ``while` `i < (n ``-` `k ``+` `1``):` `            ``# Get the ending index of``            ``# substring from starting``            ``# index i and length k``            ``j ``=` `i ``+` `k ``-` `1` `            ``# Checking for sub-string from``            ``# ith index to jth index if``            ``# st[i + 1] to st[(j-1)] is a``            ``# palindrome``            ``if` `(table[i ``+` `1``][j ``-` `1``] ``and``                    ``st[i] ``=``=` `st[j]):``                ``table[i][j] ``=` `True` `                ``if` `(k > maxLength):``                    ``start ``=` `i``                    ``maxLength ``=` `k``            ``i ``=` `i ``+` `1``        ``k ``=` `k ``+` `1``    ``print``(``"Longest palindrome substring is: "``,end``=``"")``    ``printSubStr(st, start, start ``+` `maxLength ``-` `1``)` `    ``# Return length of LPS``    ``return` `maxLength`  `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``st ``=` `"forgeeksskeegfor"``    ``l ``=` `longestPalSubstr(st)``    ``print``(``"Length is:"``, l)` `# This code is contributed by Nikita Tiwari.`

## C#

 `// C# code to implement the above idea` `using` `System;` `class` `GFG {` `    ``// A utility function to print a``    ``// substring str[low...( high - (low+1))]``    ``static` `void` `printSubStr(``string` `str, ``int` `low,``                            ``int` `high)``    ``{``        ``Console.WriteLine(str.Substring(low,``                                        ``high - low + 1));``    ``}` `    ``// This function prints the longest``    ``// palindrome substring of str[].``    ``// It also returns the length of the``    ``// longest palindrome``    ``static` `int` `longestPalSubstr(``string` `str)``    ``{``        ``// Get length of input string``        ``int` `n = str.Length;` `        ``// Table[i, j] will be false if substring``        ``// str[i..j] is not palindrome. Else``        ``// table[i, j] will be true``        ``bool``[, ] table = ``new` `bool``[n, n];` `        ``// All substrings of length 1 are palindromes``        ``int` `maxLength = 1;``        ``for` `(``int` `i = 0; i < n; ++i)``            ``table[i, i] = ``true``;` `        ``// Check for sub-string of length 2.``        ``int` `start = 0;` `        ``for` `(``int` `i = 0; i < n - 1; ++i) {``            ``if` `(str[i] == str[i + 1]) {``                ``table[i, i + 1] = ``true``;``                ``start = i;``                ``maxLength = 2;``            ``}``        ``}` `        ``// Check for lengths greater than 2.``        ``// k is length of substring``        ``for` `(``int` `k = 3; k <= n; ++k) {` `            ``// Fix the starting index``            ``for` `(``int` `i = 0; i < n - k + 1; ++i) {` `                ``// Get the ending index of substring from``                ``// starting index i and length k``                ``int` `j = i + k - 1;` `                ``// Checking for sub-string from ith index``                ``// to jth index if str.charAt(i+1) to``                ``// str.charAt(j-1) is a palindrome``                ``if` `(table[i + 1, j - 1] && str[i] == str[j]) {``                    ``table[i, j] = ``true``;``                    ``if` `(k > maxLength) {``                        ``start = i;``                        ``maxLength = k;``                    ``}``                ``}``            ``}``        ``}``        ``Console.Write(``"Longest palindrome substring is: "``);``        ``printSubStr(str, start, start + maxLength - 1);` `        ``// Return length of LPS``        ``return` `maxLength;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``string` `str = ``"forgeeksskeegfor"``;` `        ``Console.WriteLine(``"Length is: "` `+ longestPalSubstr(str));``    ``}``}` `// This code is contributed by SoumikMondal`

## Javascript

 `// Javascript Solution``    ` `    ``// A utility function to print``    ``// a substring str[low..high]``   ``function` `printSubStr(str,low,high)``   ``{``           ``console.log(str.substring(low, high + 1));``   ``}``   ` `   ``// This function prints the longest``   ``// palindrome substring of str[].``   ``// It also returns the length of the``   ``// longest palindrome``   ``function` `longestPalSubstr(str)``   ``{``        ``// Get length of input string``        ``let n = str.length;`` ` `        ``// table[i][j] will be false if``        ``// substring str[i..j] is not palindrome.``        ``// Else table[i][j] will be true``        ``let table = ``new` `Array(n);``        ``for``(let i = 0; i < n; i++)``        ``{``            ``table[i] = ``new` `Array(n);``        ``}`` ` `        ``// All substrings of length 1 are palindromes``        ``let maxLength = 1;``        ``for` `(let i = 0; i < n; ++i)``            ``table[i][i] = ``true``;`` ` `        ``// Check for sub-string of length 2.``        ``let start = 0;``        ``for` `(let i = 0; i < n - 1; ++i) ``        ``{``            ``if` `(str[i] == str[i + 1])``            ``{``                ``table[i][i + 1] = ``true``;``                ``start = i;``                ``maxLength = 2;``            ``}``        ``}`` ` `        ``// Check for lengths greater than 2.``        ``// k is length of substring``        ``for` `(let k = 3; k <= n; ++k) {`` ` `            ``// Fix the starting index``            ``for` `(let i = 0; i < n - k + 1; ++i) ``            ``{``            ` `                ``// Get the ending index of substring from``                ``// starting index i and length k``                ``let j = i + k - 1;`` ` `                ``// Checking for sub-string from ith index to``                ``// jth index if str.charAt(i+1) to``                ``// str.charAt(j-1) is a palindrome``                ``if` `(table[i + 1][j - 1]``                    ``&& str[i] == str[j]) {``                    ``table[i][j] = ``true``;`` ` `                    ``if` `(k > maxLength) {``                        ``start = i;``                        ``maxLength = k;``                    ``}``                ``}``            ``}``        ``}``        ``console.log(``"Longest palindrome substring is; "``);``        ``printSubStr(str, start,``                    ``start + maxLength - 1);`` ` `        ``// Return length of LPS``        ``return` `maxLength;``   ``}``   ` `   ``// Driver code``   ``let str = ``"forgeeksskeegfor"``;``   ``console.log(``"Length is: "` `+ longestPalSubstr(str));` `// This code is contributed by avanitrachhadiya2155`

Output
```Longest palindrome substring is: geeksskeeg
Length is: 10

```

Time complexity: O(N2). A nested traversal is needed.
Auxiliary Space: O(N2). A matrix of size N*N is needed to store the table.

### Longest Palindromic Substring using Expansion from center:

The LPS is either of even length or odd length. So the idea is to traverse the input string and for each character check if this character can be the center of a palindromic substring of odd length or even length.

Follow the steps mentioned below to implement the idea:

• Use two pointers, low and hi, for the left and right end of the current palindromic substring being found.
• Then checks if the characters at str[low] and str[hi] are the same.
• If they are, it expands the substring to the left and right by decrementing low and incrementing hi
• It continues this process until the characters at str[low] and str[hi] are unequal or until the indices are in bounds.
• If the length of the current palindromic substring becomes greater than the maximum length, it updates the maximum length.

Below is the implementation of the above idea.

## C++

 `// C++ code to implement the above idea` `#include ``using` `namespace` `std;` `// Function to print a substring str[low..high]``void` `printSubStr(string str, ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``cout << str[i];``}` `// Function to find the longest palindromic substring``int` `longestPalSubstr(string s)``{``    ``int` `n = s.length();``    ``int` `start = 0, end = 1;``    ``int` `low, hi;` `    ``// Traverse the input string``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Find longest palindromic substring of even size``        ``low = i - 1;``        ``hi = i;` `        ``// Expand substring while it is palindrome``        ``// and in bounds``        ``while` `(low >= 0 && hi < n && s[low] == s[hi]) {` `            ``// Update maximum length and starting index``            ``if` `(hi - low + 1 > end) {``                ``start = low;``                ``end = hi - low + 1;``            ``}``            ``low--;``            ``hi++;``        ``}` `        ``// Find longest palindromic substring of odd size``        ``low = i - 1;``        ``hi = i + 1;` `        ``// Expand substring while it is palindrome``        ``// and in bounds``        ``while` `(low >= 0 && hi < n && s[low] == s[hi]) {` `            ``// Update maximum length and starting index``            ``if` `(hi - low + 1 > end) {``                ``start = low;``                ``end = hi - low + 1;``              ` `            ``}``               ``low--;``            ``hi++;``        ``}``    ``}` `    ``// Print the longest palindromic substring``    ``cout << ``"Longest palindrome substring is: "``;``    ``printSubStr(s, start, start + end - 1);` `    ``// Return output length``    ``return` `end;``}` `// Driver code``int` `main()``{``    ``string str = ``"forgeeksskeegfor"``;` `    ``// Function call``    ``cout << ``"\nLength is: "` `<< longestPalSubstr(str);``    ``return` `0;``}` `// This code is contributed by Tapesh(tapeshdua420)`

## C

 `#include ``#include ` `// Function to print a substring str[low..high]``void` `printSubStr(``char` `str[], ``int` `low, ``int` `high)``{``    ``for` `(``int` `i = low; i <= high; ++i)``        ``printf``(``"%c"``, str[i]);``}` `// Function to find the longest palindromic substring``int` `longestPalSubstr(``char` `s[])``{``    ``int` `n = ``strlen``(s);``    ``int` `start = 0, end = 1;``    ``int` `low, hi;` `    ``// Traverse the input string``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Find longest palindromic substring of even size``        ``low = i - 1;``        ``hi = i;` `        ``// Expand substring while it is palindrome``        ``// and in bounds``        ``while` `(low >= 0 && hi < n && s[low] == s[hi]) {` `            ``// Update maximum length and starting index``            ``if` `(hi - low + 1 > end) {``                ``start = low;``                ``end = hi - low + 1;``            ``}``            ``low--;``            ``hi++;``        ``}` `        ``// Find longest palindromic substring of odd size``        ``low = i - 1;``        ``hi = i + 1;` `        ``// Expand substring while it is palindrome``        ``// and in bounds``        ``while` `(low >= 0 && hi < n && s[low] == s[hi]) {` `            ``// Update maximum length and starting index``            ``if` `(hi - low + 1 > end) {``                ``start = low;``                ``end = hi - low + 1;``            ``}``            ``low--;``            ``hi++;``        ``}``    ``}` `    ``// Print the longest palindromic substring``    ``printf``(``"Longest palindrome substring is: "``);``    ``printSubStr(s, start, start + end - 1);` `    ``// Return output length``    ``return` `end;``}` `// Driver code``int` `main()``{``    ``char` `str[] = ``"forgeeksskeegfor"``;` `    ``// Function call``    ``printf``(``"\nLength is: %d"``, longestPalSubstr(str));``    ``return` `0;``}`

## Java

 `class` `LongestPalinSubstring {``    ``// Function to print a substring str[low..high]``    ``static` `void` `printSubStr(String str, ``int` `low, ``int` `high) {``        ``for` `(``int` `i = low; i <= high; ++i)``            ``System.out.print(str.charAt(i));``        ``System.out.println();``    ``}` `    ``// Function to find the longest palindromic substring``    ``static` `int` `longestPalSubstr(String s) {``        ``int` `n = s.length();``        ``int` `start = ``0``, end = ``1``;``        ``int` `low, hi;` `        ``// Traverse the input string``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// Find longest palindromic substring of even size``            ``low = i - ``1``;``            ``hi = i;` `            ``// Expand substring while it is palindrome and in bounds``            ``while` `(low >= ``0` `&& hi < n && s.charAt(low) == s.charAt(hi)) {` `                ``// Update maximum length and starting index``                ``if` `(hi - low + ``1` `> end) {``                    ``start = low;``                    ``end = hi - low + ``1``;``                ``}``                ``low--;``                ``hi++;``            ``}` `            ``// Find longest palindromic substring of odd size``            ``low = i - ``1``;``            ``hi = i + ``1``;` `            ``// Expand substring while it is palindrome and in bounds``            ``while` `(low >= ``0` `&& hi < n && s.charAt(low) == s.charAt(hi)) {` `                ``// Update maximum length and starting index``                ``if` `(hi - low + ``1` `> end) {``                    ``start = low;``                    ``end = hi - low + ``1``;``                ``}``                ``low--;``                ``hi++;``            ``}``        ``}` `        ``// Print the longest palindromic substring``        ``System.out.print(``"Longest palindrome substring is: "``);``        ``printSubStr(s, start, start + end - ``1``);` `        ``// Return output length``        ``return` `end;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"forgeeksskeegfor"``;``        ``int` `length = longestPalSubstr(s);``        ``System.out.println(``"Length: "` `+ length);``    ``}``}`

## Python3

 `def` `printSubStr(s, low, high):``    ``for` `i ``in` `range``(low, high ``+` `1``):``        ``print``(s[i], end``=``"")``    ``print``()` `def` `longestPalSubstr(s):``    ``n ``=` `len``(s)``    ``start ``=` `0``    ``end ``=` `1` `    ``for` `i ``in` `range``(n):``        ``# Find the longest palindromic substring of even length``        ``low ``=` `i ``-` `1``        ``hi ``=` `i` `        ``while` `low >``=` `0` `and` `hi < n ``and` `s[low] ``=``=` `s[hi]:``            ``if` `hi ``-` `low ``+` `1` `> end:``                ``start ``=` `low``                ``end ``=` `hi ``-` `low ``+` `1``            ``low ``-``=` `1``            ``hi ``+``=` `1` `        ``# Find the longest palindromic substring of odd length``        ``low ``=` `i ``-` `1``        ``hi ``=` `i ``+` `1` `        ``while` `low >``=` `0` `and` `hi < n ``and` `s[low] ``=``=` `s[hi]:``            ``if` `hi ``-` `low ``+` `1` `> end:``                ``start ``=` `low``                ``end ``=` `hi ``-` `low ``+` `1``            ``low ``-``=` `1``            ``hi ``+``=` `1` `    ``# Print the longest palindromic substring``    ``print``(``"Longest palindrome substring is: "``, end``=``"")``    ``printSubStr(s, start, start ``+` `end ``-` `1``)` `    ``# Return the length of the longest palindromic substring``    ``return` `end` `# Driver Code:``if` `__name__``=``=``'__main__'``:``    ``s``=``"forgeeksskeegfor"``    ``length ``=` `longestPalSubstr(s)``    ``print``(``"Length:"``, length)``    ` `# Code Contributed by atharvajadhav11`

## C#

 `using` `System;` `class` `GFG {``    ``// Function to print a substring``    ``static` `void` `PrintSubStr(``string` `s, ``int` `low, ``int` `high)``    ``{``        ``for` `(``int` `i = low; i <= high; i++) {``            ``Console.Write(s[i]);``        ``}``        ``Console.WriteLine();``    ``}` `    ``// Function to find the longest palindromic substring``    ``static` `int` `LongestPalSubstr(``string` `s)``    ``{``        ``int` `n = s.Length;``        ``int` `start = 0;``        ``int` `end = 1;` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``// Find the longest palindromic substring of``            ``// even length``            ``int` `low = i - 1;``            ``int` `hi = i;` `            ``while` `(low >= 0 && hi < n && s[low] == s[hi]) {``                ``if` `(hi - low + 1 > end) {``                    ``start = low;``                    ``end = hi - low + 1;``                ``}``                ``low--;``                ``hi++;``            ``}` `            ``// Find the longest palindromic substring of odd``            ``// length``            ``low = i - 1;``            ``hi = i + 1;` `            ``while` `(low >= 0 && hi < n && s[low] == s[hi]) {``                ``if` `(hi - low + 1 > end) {``                    ``start = low;``                    ``end = hi - low + 1;``                ``}``                ``low--;``                ``hi++;``            ``}``        ``}` `        ``// Print the longest palindromic substring``        ``Console.Write(``"Longest palindrome substring is: "``);``        ``PrintSubStr(s, start, start + end - 1);` `        ``// Return the length of the longest palindromic``        ``// substring``        ``return` `end;``    ``}` `    ``// Driver Code:``    ``static` `void` `Main()``    ``{``        ``string` `s = ``"forgeeksskeegfor"``;``        ``int` `length = LongestPalSubstr(s);``        ``Console.WriteLine(``"Length: "` `+ length);``    ``}``}`

## Javascript

 `// Function to print a substring str[low..high]``function` `printSubStr(str, low, high) {``    ``for` `(let i = low; i <= high; ++i) {``        ``console.log(str[i]);``    ``}``}` `// Function to find the longest palindromic substring``function` `longestPalSubstr(s) {``    ``const n = s.length;``    ``let start = 0, end = 1;``    ``let low, hi;` `    ``// Traverse the input string``    ``for` `(let i = 0; i < n; i++) {` `        ``// Find the longest palindromic substring of even size``        ``low = i - 1;``        ``hi = i;` `        ``// Expand substring while it is a palindrome``        ``// and in bounds``        ``while` `(low >= 0 && hi < n && s[low] === s[hi]) {` `            ``// Update the maximum length and starting index``            ``if` `(hi - low + 1 > end) {``                ``start = low;``                ``end = hi - low + 1;``            ``}``            ``low--;``            ``hi++;``        ``}` `        ``// Find the longest palindromic substring of odd size``        ``low = i - 1;``        ``hi = i + 1;` `        ``// Expand substring while it is a palindrome``        ``// and in bounds``        ``while` `(low >= 0 && hi < n && s[low] === s[hi]) {` `            ``// Update the maximum length and starting index``            ``if` `(hi - low + 1 > end) {``                ``start = low;``                ``end = hi - low + 1;``            ``}``            ``low--;``            ``hi++;``        ``}``    ``}` `    ``// Print the longest palindromic substring``    ``console.log(``"Longest palindrome substring is: "``);``    ``printSubStr(s, start, start + end - 1);` `    ``// Return the output length``    ``return` `end;``}`  `    ``const str = ``"forgeeksskeegfor"``;` `   ` `    ``console.log(``"\nLength is: "` `+ longestPalSubstr(str));`

Output
```Longest palindrome substring is: geeksskeeg
Length is: 10

```

Time complexity: O(N2), where N is the length of the input string
Auxiliary Space: O(1), No extra space used.

Previous
Next