Related Articles

# Number of sub-strings that contain the given character exactly k times

• Difficulty Level : Hard
• Last Updated : 27 May, 2021

Given the string str, a character c, and an integer k > 0. The task is to find the number of sub-strings that contain the character c exactly k times.

Examples:

Input: str = “abada”, c = ‘a’, K = 2
Output:

Input: str = “55555”, c = ‘5’, k = 4
Output:

Naive approach: A simple solution is to generate all the sub-strings and check whether the count of a given character is exactly k times.
The time complexity of this approach is O(n2).

Efficient approach: An efficient solution is to use the sliding window technique. Find the sub-string that exactly contains the given character k times, starting with character c. Count the number of characters on either side of the sub-string. Multiply the counts to get the number of possible sub-strings. The time complexity of this approach is O(n).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count of required sub-strings``int` `countSubString(string s, ``char` `c, ``int` `k)``{` `    ``// Left and right counters for characters on``    ``// both sides of sub-string window``    ``int` `leftCount = 0, rightCount = 0;` `    ``// Left and right pointer on both``    ``// sides of sub-string window``    ``int` `left = 0, right = 0;` `    ``// Initialize the frequency``    ``int` `freq = 0;` `    ``// Result and length of string``    ``int` `result = 0, len = s.length();` `    ``// Initialize the left pointer``    ``while` `(s[left] != c && left < len) {``        ``left++;``        ``leftCount++;``    ``}` `    ``// Initialize the right pointer``    ``right = left + 1;``    ``while` `(freq != (k - 1) && (right - 1) < len) {``        ``if` `(s[right] == c)``            ``freq++;``        ``right++;``    ``}` `    ``// Traverse all the window sub-strings``    ``while` `(left < len && (right - 1) < len) {` `        ``// Counting the characters on left side``        ``// of the sub-string window``        ``while` `(s[left] != c && left < len) {``            ``left++;``            ``leftCount++;``        ``}` `        ``// Counting the characters on right side``        ``// of the sub-string window``        ``while` `(right < len && s[right] != c) {``            ``if` `(s[right] == c)``                ``freq++;``            ``right++;``            ``rightCount++;``        ``}` `        ``// Add the possible sub-strings``        ``// on both sides to result``        ``result = result + (leftCount + 1) * (rightCount + 1);` `        ``// Setting the frequency for next``        ``// sub-string window``        ``freq = k - 1;` `        ``// Reset the left and right counters``        ``leftCount = 0;``        ``rightCount = 0;` `        ``left++;``        ``right++;``    ``}``    ``return` `result;``}` `// Driver code``int` `main()``{``    ``string s = ``"abada"``;``    ``char` `c = ``'a'``;``    ``int` `k = 2;` `    ``cout << countSubString(s, c, k) << ``"\n"``;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{``    ` `// Function to return the count of required sub-strings``static` `int` `countSubString(``char``[] s, ``char` `c, ``int` `k)``{` `    ``// Left and right counters for characters on``    ``// both sides of sub-string window``    ``int` `leftCount = ``0``, rightCount = ``0``;` `    ``// Left and right pointer on both``    ``// sides of sub-string window``    ``int` `left = ``0``, right = ``0``;` `    ``// Initialize the frequency``    ``int` `freq = ``0``;` `    ``// Result and length of string``    ``int` `result = ``0``, len = s.length;` `    ``// Initialize the left pointer``    ``while` `(s[left] != c && left < len)``    ``{``        ``left++;``        ``leftCount++;``    ``}` `    ``// Initialize the right pointer``    ``right = left + ``1``;``    ``while` `(freq != (k - ``1``) && (right - ``1``) < len)``    ``{``        ``if` `(s[right] == c)``            ``freq++;``        ``right++;``    ``}` `    ``// Traverse all the window sub-strings``    ``while` `(left < len && (right - ``1``) < len)``    ``{` `        ``// Counting the characters on left side``        ``// of the sub-string window``        ``while` `(s[left] != c && left < len)``        ``{``            ``left++;``            ``leftCount++;``        ``}` `        ``// Counting the characters on right side``        ``// of the sub-string window``        ``while` `(right < len && s[right] != c)``        ``{``            ``if` `(s[right] == c)``                ``freq++;``            ``right++;``            ``rightCount++;``        ``}` `        ``// Add the possible sub-strings``        ``// on both sides to result``        ``result = result + (leftCount + ``1``) * (rightCount + ``1``);` `        ``// Setting the frequency for next``        ``// sub-string window``        ``freq = k - ``1``;` `        ``// Reset the left and right counters``        ``leftCount = ``0``;``        ``rightCount = ``0``;` `        ``left++;``        ``right++;``    ``}``    ``return` `result;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``String s = ``"abada"``;``    ``char` `c = ``'a'``;``    ``int` `k = ``2``;` `    ``System.out.println(countSubString(s.toCharArray(), c, k));``}``}` `// This code has been contributed by 29AjayKumar`

## Python3

 `# Python 3 implementation of the approach` `# Function to return the count``# of required sub-strings``def` `countSubString(s, c, k):``    ` `    ``# Left and right counters for characters``    ``# on both sides of sub-string window``    ``leftCount ``=` `0``    ``rightCount ``=` `0` `    ``# Left and right pointer on both``    ``# sides of sub-string window``    ``left ``=` `0``    ``right ``=` `0` `    ``# Initialize the frequency``    ``freq ``=` `0` `    ``# Result and length of string``    ``result ``=` `0``    ``len1 ``=` `len``(s)` `    ``# Initialize the left pointer``    ``while` `(s[left] !``=` `c ``and` `left < len1):``        ``left ``+``=` `1``        ``leftCount ``+``=` `1` `    ``# Initialize the right pointer``    ``right ``=` `left ``+` `1``    ``while` `(freq !``=` `(k ``-` `1``) ``and``          ``(right ``-` `1``) < len1):``        ``if` `(s[right] ``=``=` `c):``            ``freq ``+``=` `1``        ``right ``+``=` `1` `    ``# Traverse all the window sub-strings``    ``while` `(left < len1 ``and``          ``(right ``-` `1``) < len1):``        ` `        ``# Counting the characters on left side``        ``# of the sub-string window``        ``while` `(s[left] !``=` `c ``and` `left < len1):``            ``left ``+``=` `1``            ``leftCount ``+``=` `1` `        ``# Counting the characters on right side``        ``# of the sub-string window``        ``while` `(right < len1 ``and``             ``s[right] !``=` `c):``            ``if` `(s[right] ``=``=` `c):``                ``freq ``+``=` `1``            ``right ``+``=` `1``            ``rightCount ``+``=` `1` `        ``# Add the possible sub-strings``        ``# on both sides to result``        ``result ``=` `(result ``+` `(leftCount ``+` `1``) ``*``                           ``(rightCount ``+` `1``))` `        ``# Setting the frequency for next``        ``# sub-string window``        ``freq ``=` `k ``-` `1` `        ``# Reset the left and right counters``        ``leftCount ``=` `0``        ``rightCount ``=` `0` `        ``left ``+``=` `1``        ``right ``+``=` `1` `    ``return` `result` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``s ``=` `"abada"``    ``c ``=` `'a'``    ``k ``=` `2` `    ``print``(countSubString(s, c, k))` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``    ` `// Function to return the count of required sub-strings``static` `int` `countSubString(``char``[] s, ``char` `c, ``int` `k)``{` `    ``// Left and right counters for characters on``    ``// both sides of sub-string window``    ``int` `leftCount = 0, rightCount = 0;` `    ``// Left and right pointer on both``    ``// sides of sub-string window``    ``int` `left = 0, right = 0;` `    ``// Initialize the frequency``    ``int` `freq = 0;` `    ``// Result and length of string``    ``int` `result = 0, len = s.Length;` `    ``// Initialize the left pointer``    ``while` `(s[left] != c && left < len)``    ``{``        ``left++;``        ``leftCount++;``    ``}` `    ``// Initialize the right pointer``    ``right = left + 1;``    ``while` `(freq != (k - 1) && (right - 1) < len)``    ``{``        ``if` `(s[right] == c)``            ``freq++;``        ``right++;``    ``}` `    ``// Traverse all the window sub-strings``    ``while` `(left < len && (right - 1) < len)``    ``{` `        ``// Counting the characters on left side``        ``// of the sub-string window``        ``while` `(s[left] != c && left < len)``        ``{``            ``left++;``            ``leftCount++;``        ``}` `        ``// Counting the characters on right side``        ``// of the sub-string window``        ``while` `(right < len && s[right] != c)``        ``{``            ``if` `(s[right] == c)``                ``freq++;``            ``right++;``            ``rightCount++;``        ``}` `        ``// Add the possible sub-strings``        ``// on both sides to result``        ``result = result + (leftCount + 1) * (rightCount + 1);` `        ``// Setting the frequency for next``        ``// sub-string window``        ``freq = k - 1;` `        ``// Reset the left and right counters``        ``leftCount = 0;``        ``rightCount = 0;` `        ``left++;``        ``right++;``    ``}``    ``return` `result;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``String s = ``"abada"``;``    ``char` `c = ``'a'``;``    ``int` `k = 2;` `    ``Console.WriteLine(countSubString(s.ToCharArray(), c, k));``}``}` `// This code contributed by Rajput-Ji`

## PHP

 ``

## Javascript

 ``
Output:
`4`

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up