Skip to content
Related Articles

Related Articles

Find the count of palindromic sub-string of a string in its sorted form

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 25 Jun, 2022

Given string str consisting of lowercase English alphabets, the task is to find the total number of palindromic sub-strings present in the sorted form of str.
Examples: 
 

Input: str = “acbbd” 
Output:
All palindromic sub-string in it’s sorted form (“abbcd”) are “a”, “b”, “b”, “bb”, “c” and “d”.
Input: str = “abbabdbd” 
Output: 16 
 

 

Naive approach: One way is to sort the given string and then count the total number of sub-strings present which are palindromes. For finding a number of palindromic sub-strings this approach can be used which has a time complexity of O(n^2).
Optimized approach: An efficient way is to count the frequency of each character and then for each frequency total number of palindromes will (n*(n+1))/2 as all the palindromic sub-strings of a sorted string will consist of the same character. 
For example, palindromic sub-string for the string “aabbbcd” will be “a”, “aa”, …, “bbb”, “c”, … etc. Time complexity for this approach will be O(n). 
 

  • Create a hash table for storing the frequencies of each character of the string str.
  • Traverse the hash table and for each non-zero frequency add (hash[i] * (hash[i]+1)) / 2 to the sum.
  • Print the sum in the end.

Below is the implementation of the above approach: 
 

C++




// CPP program to find the count of palindromic sub-string
// of a string in it's ascending form
#include <bits/stdc++.h>
using namespace std;
 
const int MAX_CHAR = 26;
 
// function to return count of palindromic sub-string
int countPalindrome(string str)
{
    int n = str.size();
    int sum = 0;
 
    // calculate frequency
    int hashTable[MAX_CHAR];
    for (int i = 0; i < n; i++)
        hashTable[str[i] - 'a']++;
 
    // calculate count of palindromic sub-string
    for (int i = 0; i < 26; i++) {
        if (hashTable[i])
            sum += (hashTable[i] * (hashTable[i] + 1) / 2);
    }
 
    // return result
    return sum;
}
 
// driver program
int main()
{
    string str = "ananananddd";
 
    cout << countPalindrome(str);
    return 0;
}

Java




// Java program to find the count of palindromic sub-string
// of a string in it's ascending form
 
class GFG {
 
    final static int MAX_CHAR = 26;
 
// function to return count of palindromic sub-string
    static int countPalindrome(String str) {
        int n = str.length();
        int sum = 0;
 
        // calculate frequency
        int hashTable[] = new int[MAX_CHAR];
        for (int i = 0; i < n; i++) {
            hashTable[str.charAt(i) - 'a']++;
        }
 
        // calculate count of palindromic sub-string
        for (int i = 0; i < 26; i++) {
            if (hashTable[i] != 0) {
                sum += (hashTable[i] * (hashTable[i] + 1) / 2);
            }
        }
 
        // return result
        return sum;
    }
 
// driver program
    public static void main(String[] args) {
        String str = "ananananddd";
 
        System.out.println(countPalindrome(str));
 
    }
}

Python3




# Python3 program to find the count of
# palindromic sub-string of a string
# in it's ascending form
MAX_CHAR = 26
 
# function to return count of
# palindromic sub-string
def countPalindrome(str):
 
    n = len (str)
    sum = 0
 
    # calculate frequency
    hashTable = [0] * MAX_CHAR
    for i in range(n):
        hashTable[ord(str[i]) -
                  ord('a')] += 1
 
    # calculate count of palindromic
    # sub-string
    for i in range(26) :
        if (hashTable[i]):
            sum += (hashTable[i] *
                   (hashTable[i] + 1) // 2)
 
    # return result
    return sum
 
# Driver Code
if __name__ == "__main__":
 
    str = "ananananddd"
 
    print (countPalindrome(str))
 
# This code is contributed by ita_c

C#




// C# program to find the count of palindromic sub-string
// of a string in it's ascending form
using System;
                     
public class GFG{
  
    readonly static int MAX_CHAR = 26;
  
// function to return count of palindromic sub-string
    static int countPalindrome(String str) {
        int n = str.Length;
        int sum = 0;
  
        // calculate frequency
        int []hashTable = new int[MAX_CHAR];
        for (int i = 0; i < n; i++) {
            hashTable[str[i] - 'a']++;
        }
  
        // calculate count of palindromic sub-string
        for (int i = 0; i < 26; i++) {
            if (hashTable[i] != 0) {
                sum += (hashTable[i] * (hashTable[i] + 1) / 2);
            }
        }
  
        // return result
        return sum;
    }
  
// driver program
    public static void Main() {
        String str = "ananananddd";
  
        Console.Write(countPalindrome(str));
  
    }
}
 
// This code is contributed by Rajput-Ji

PHP




<?php
// PHP program to find the count of
// palindromic sub-string of a string
// in it's ascending form
$MAX_CHAR = 26;
 
// function to return count of
// palindromic sub-string
function countPalindrome($str)
{
    global $MAX_CHAR;
    $n = strlen($str);
    $sum = 0;
 
    // calculate frequency
    $hashTable = array_fill(0, $MAX_CHAR, 0);
    for ($i = 0; $i < $n; $i++)
        $hashTable[ord($str[$i]) - ord('a')]++;
 
    // calculate count of palindromic sub-string
    for ($i = 0; $i < 26; $i++)
    {
        if ($hashTable[$i])
            $sum += (int)($hashTable[$i] *
                         ($hashTable[$i] + 1) / 2);
    }
 
    // return result
    return $sum;
}
 
// Driver Code
$str = "ananananddd";
 
echo countPalindrome($str);
 
// This code is contributed by mits
?>

Javascript




<script>
 
// Javascript program to find the count of palindromic sub-string
// of a string in it's ascending form
 
var MAX_CHAR = 26;
 
// function to return count of palindromic sub-string
function countPalindrome(str)
{
    var n = str.length;
    var sum = 0;
 
    // calculate frequency
    var hashTable = Array(MAX_CHAR).fill(0);
    for (var i = 0; i < n; i++)
        hashTable[str[i].charCodeAt(0) - 'a'.charCodeAt(0)]++;
 
    // calculate count of palindromic sub-string
    for (var i = 0; i < 26; i++) {
        if (hashTable[i])
            sum += (hashTable[i] * (hashTable[i] + 1) / 2);
    }
 
    // return result
    return sum;
}
 
// driver program
var str = "ananananddd";
document.write( countPalindrome(str));
 
</script>

Output: 

26

 

Time Complexity: O(N), as we are using a loop to traverse N times. Where N is the length of the string.

Auxiliary Space: O(26), as we are using extra space for the hash table.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!