# Count All Palindrome Sub-Strings in a String | Set 2

• Difficulty Level : Hard
• Last Updated : 05 Oct, 2022

Given a string, the task is to count all palindrome substring in a given string. Length of palindrome substring is greater than or equal to 2.

```Examples:
Input : str = "abaab"
Output: 3
Explanation :
All palindrome substring are :
"aba", "aa", "baab"

Input : str = "abbaeae"
Output: 4
Explanation :
All palindrome substring are :
"bb", "abba", "aea", "eae":```

We have discussed a dynamic programming based solution in below post. Count All Palindrome Sub-Strings in a String | Set 1 The solution discussed here is extension of Longest Palindromic Substring problem

The idea is for each character in the given input string, we consider it as midpoint of a palindrome and expand it in both directions to find all palindromes of even and odd lengths. We use hashmap to keep track of all the distinct palindromes of length greater than 1 and return map size which have count of all possible palindrome substrings.

Implementation:

## CPP

 `// C++ program to count all distinct palindromic``// substrings of a string.``#include ``using` `namespace` `std;` `// Returns total number of palindrome substring of``// length greater than equal to 2``int` `countPalindromes(string s)``{``    ``unordered_map m;``    ``for` `(``int` `i = 0; i < s.length(); i++) {` `        ``// check for odd length palindromes``        ``for` `(``int` `j = 0; j <= i; j++) {` `            ``if` `(!s[i + j])``                ``break``;` `            ``if` `(s[i - j] == s[i + j]) {` `                ``// check for palindromes of length``                ``// greater than 1``                ``if` `((i + j + 1) - (i - j) > 1)``                    ``m[s.substr(i - j,``                        ``(i + j + 1) - (i - j))]++;` `            ``} ``else``                ``break``;``        ``}` `        ``// check for even length palindromes``        ``for` `(``int` `j = 0; j <= i; j++) {``            ``if` `(!s[i + j + 1])``                ``break``;``            ``if` `(s[i - j] == s[i + j + 1]) {` `                ``// check for palindromes of length``                ``// greater than 1``                ``if` `((i + j + 2) - (i - j) > 1)``                    ``m[s.substr(i - j,``                         ``(i + j + 2) - (i - j))]++;` `            ``} ``else``                ``break``;``        ``}``    ``}``    ``return` `m.size();``}` `// Driver code``int` `main()``{``    ``string s = ``"abbaeae"``;``    ``cout << countPalindromes(s) << endl;``    ``return` `0;``}`

## Java

 `// Java Program to count palindrome substring``// in a string``public` `class` `PalindromeSubstring {``    ` `    ``// Method which return count palindrome substring``    ``static` `int` `countPS(String str){``        ``String temp = ``""``;``        ``StringBuffer stf;``        ``int` `count = ``0``;``        ``// Iterate the loop twice``        ``for` `(``int` `i = ``0``; i < str.length(); i++) {``            ``for` `(``int` `j = i + ``1``; j <= str.length(); j++) {``                ``// Get each substring``                ``temp = str.substring(i, j);``                ` `                ``// If length is greater than or equal to two``                ``// Check for palindrome   ``                ``if` `(temp.length() >= ``2``) {``                    ``// Use StringBuffer class to reverse the string``                    ``stf = ``new` `StringBuffer(temp);``                    ``stf.reverse();``                    ``// Compare substring with reverse of substring``                    ``if` `(stf.toString().compareTo(temp) == ``0``)``                        ``count++;``                ``}``            ``}``        ``}``        ``// return the count``        ``return` `count;``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `main(String args[]) ``throws` `Exception {``        ``// Declare and initialize the string``        ``String str = ``"abbaeae"``;``        ``// Call the method``        ``System.out.println(countPS(str));``    ``}``} ``// This code is contributes by hungundji`

## Python3

 `# Python program to count all distinct palindromic``# substrings of a string.` `# Returns total number of palindrome substring of``# length greater than equal to 2``def` `countPalindromes(s):` `    ``m ``=` `{}``    ``for` `i ``in` `range``(``len``(s)):` `        ``# check for odd length palindromes``        ``for` `j ``in` `range``(i``+``1``):` `            ``if` `(i ``+` `j >``=` `len``(s)):``                ``break` `            ``if` `(s[i ``-` `j] ``=``=` `s[i ``+` `j]):` `                ``# check for palindromes of length``                ``# greater than 1``                ``if` `((i ``+` `j ``+` `1``) ``-` `(i ``-` `j) > ``1``):``                    ``if``(s[i ``-` `j:(i ``+` `j ``+` `1``)] ``in` `m):``                        ``m[s[i ``-` `j:(i ``+` `j ``+` `1``)]] ``+``=` `1``                    ``else``:``                        ``m[s[i ``-` `j:(i ``+` `j ``+` `1``)]] ``=` `1` `            ``else``:``                ``break` `        ``# check for even length palindromes``        ``for` `j ``in` `range``(i``+``1``):``            ``if` `(i ``+` `j ``+` `1` `>``=` `len``(s)):``                ``break``            ``if` `(s[i ``-` `j] ``=``=` `s[i ``+` `j ``+` `1``]):` `                ``# check for palindromes of length``                ``# greater than 1``                ``if` `((i ``+` `j ``+` `2``) ``-` `(i ``-` `j) > ``1``):``                    ``if``(s[i ``-` `j:i ``+` `j ``+` `2``] ``in` `m):``                        ``m[s[i ``-` `j:(i ``+` `j ``+` `2``)]] ``+``=` `1``                    ``else``:``                        ``m[s[i ``-` `j:(i ``+` `j ``+` `2``)]] ``=` `1` `            ``else``:``                ``break``        ` `    ``return` `len``(m)` `# Driver code``s ``=` `"abbaeae"``print``(countPalindromes(s))` `# This code is contributed by shinjanpatra`

## C#

 `// C# Program to count palindrome substring``// in a string``using` `System;` `class` `GFG``{``    ` `    ``// Method which return count palindrome substring``    ``static` `int` `countPS(String str)``    ``{``        ``String temp = ``""``;``        ``String stf;``        ``int` `count = 0;``        ` `        ``// Iterate the loop twice``        ``for` `(``int` `i = 0; i < str.Length; i++)``        ``{``            ``for` `(``int` `j = i + 1;``                     ``j <= str.Length; j++)``            ``{``                ``// Get each substring``                ``temp = str.Substring(i, j-i);``                ` `                ``// If length is greater than or equal to two``                ``// Check for palindrome``                ``if` `(temp.Length >= 2)``                ``{``                    ``// Use StringBuffer class to reverse``                    ``// the string``                    ``stf = temp;``                    ``stf = reverse(temp);``                    ` `                    ``// Compare substring with reverse of substring``                    ``if` `(stf.ToString().CompareTo(temp) == 0)``                        ``count++;``                ``}``            ``}``        ``}``        ` `        ``// return the count``        ``return` `count;``    ``}``    ` `    ``static` `String reverse(String input)``    ``{``        ``char``[] a = input.ToCharArray();``        ``int` `l, r = 0;``        ``r = a.Length - 1;` `        ``for` `(l = 0; l < r; l++, r--)``        ``{``            ``// Swap values of l and r``            ``char` `temp = a[l];``            ``a[l] = a[r];``            ``a[r] = temp;``        ``}``        ``return` `String.Join(``""``,a);``    ``}``    ` `    ``// Driver Code``    ``public` `static` `void` `Main(String []args)``    ``{``        ``// Declare and initialize the string``        ``String str = ``"abbaeae"``;``        ` `        ``// Call the method``        ``Console.WriteLine(countPS(str));``    ``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

`4`

Time complexity O(n2) Auxiliary Space O(n) This article is contributed by Ankur Singh. 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.

In the Approach discussed above we are using a unordered map which is taking O(n) space but we can do the same thing without using any extra space.Instead of making a hashmap we can directly count the palindromic substring.

Implementation:

## C++

 `#include ``using` `namespace` `std;``int` `countPalindromes(string s)``{``    ``int` `n = s.size();``    ``int` `count = 0;``    ``for` `(``int` `i = 0; i < s.size(); i++) {``        ``int` `left = i - 1;``        ``int` `right = i + 1;``        ``while` `(left >= 0 and right < n) {``            ``if` `(s[left] == s[right])``                ``count++;``            ``else``                ``break``;``            ``left--;``            ``right++;``        ``}``    ``}` `    ``for` `(``int` `i = 0; i < s.size(); i++) {``        ``int` `left = i;``        ``int` `right = i + 1;``        ``while` `(left >= 0 and right < n) {``            ``if` `(s[left] == s[right])``                ``count++;``            ``else``                ``break``;``            ``left--;``            ``right++;``        ``}``    ``}``    ``return` `count;``}``int` `main()``{` `    ``string s = ``"abbaeae"``;``    ``cout << countPalindromes(s) << endl;``    ``return` `0;``}``// This  code is contributed by Arpit Jain`

## Java

 `class` `GFG {``  ` `      ``public` `static` `int` `countPalindromes(String s){``          ``int` `count = ``0``;``        ``for``(``int` `i=``0``; i 2.``            ``count += expandFromCenter(s, i-``1``, i+``1``) +  expandFromCenter(s, i , i+``1``);``        ``}``        ` `        ``return` `count;  ``    ``}``  ` `      ``public` `static` `int` `expandFromCenter(String s, ``int` `left, ``int` `right){``        ``int` `count = ``0``;``          ``//As we expand from the center and find if the character matches, we increase the count.``        ``while``(left >= ``0` `&& right < s.length() && s.charAt(left) == s.charAt(right)){``              ``count++;``              ``left--;``              ``right++;``        ``}``        ``return` `count;``    ``}``  ` `    ``public` `static` `void` `main (String[] args) {``        ``String s = ``"abbaeae"``;``           ``System.out.println(countPalindromes(s));``    ``}``}`

## Python

 `# Python program to count all distinct palindromic``# substrings of a string.` `# Returns total number of palindrome substring of``# length greater than equal to 2`  `def` `countPalindromes(s):``    ``n ``=` `len``(s)``    ``count ``=` `0``    ``for` `i ``in` `range``(``0``, n):``        ``left ``=` `i``-``1``        ``right ``=` `i``+``1``        ``while` `left >``=` `0` `and` `right < n:``            ``if` `s[left] ``=``=` `s[right]:``                ``count ``+``=` `1``            ``else``:``                ``break``            ``left ``-``=` `1``            ``right ``+``=` `1``    ``for` `i ``in` `range``(``0``, n):``        ``left ``=` `i``        ``right ``=` `i``+``1``        ``while` `left >``=` `0` `and` `right < n:``            ``if` `s[left] ``=``=` `s[right]:``                ``count ``+``=` `1``            ``else``:``                ``break``            ``left ``-``=` `1``            ``right ``+``=` `1``    ``return` `count` `   ``# Driver code``s ``=` `"abbaeae"``print``(countPalindromes(s))` `# This code is contributed by Arpit Jain`

## C#

 `using` `System;` `public` `class` `GFG{` `  ``public` `static` `int` `countPalindromes(``string` `s){``    ``int` `count = 0;``    ``for``(``int` `i = 0; i < s.Length; i++)``    ``{``      ``// Taking every node as a center and expanding``      ``// it from there to check if it is a palindrome or not.``      ``// This will make sure that the length of the string to be checked > 2.``      ``count += expandFromCenter(s, i - 1, i + 1) +  expandFromCenter(s, i , i + 1);``    ``}` `    ``return` `count;  ``  ``}` `  ``public` `static` `int` `expandFromCenter(``string` `s, ``int` `left, ``int` `right){``    ``int` `count = 0;` `    ``// As we expand from the center and find``    ``// if the character matches, we increase the count.``    ``while``(left >= 0 && right < s.Length && s[left] == s[right]){``      ``count++;``      ``left--;``      ``right++;``    ``}``    ``return` `count;``  ``}` `  ``public` `static` `void` `Main (``string``[] args) {``    ``string` `s = ``"abbaeae"``;``    ``Console.WriteLine(countPalindromes(s));``  ``}``}` `// This code is contributed by Shubham singh`

## Javascript

 ``

Output

`4`

Time complexity is O(n^2) in worst case because we are running one while loop inside a for loop because in while loop we are expanding to both directions so that’s why it’s  O(n/2) in worst case when all characters are same eg : “aaaaaaaa” .

But we are not using any extra space , Space Complexity is O(1) .

My Personal Notes arrow_drop_up