# Sub-strings of length K containing same character

Given a string ‘str’ and an integer ‘k’, the task is to count the number of sub-strings of length ‘k’ which are comprised of the same character. Given string contains only lowercase alphabets.

Examples:

```Input: str = "aaaabbbccdddd", k=4
Output: 2
The sub-strings of length 4 which contain identical
characters are 'aaaa' and 'dddd'. So, the count is 2.

Input: str = "aaaaaa", k=4
Output: 3
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A simple approach:

• Find all the sub-strings of the string that are of length ‘k’.
• Check if those sub-strings are composed of only ‘1’ character.
• If the above conditions hold then increase the count.
• Display the count.

Efficient approach: We will use Window sliding technique to solve this problem.

• Take a sub-string of length ‘k’ (which is the first ‘k’ characters).
• Then, add next character to the sub-string.
• If the length of the sub-string is greater than ‘k’ then remove the character from the beginning of the string.
• And, count the frequency of the characters in the sub-string with the help of a map.
• If the frequency of one of the sub-string’s character is equal to length of the sub-string itself i.e. all the characters are same.
• Then, increase the count else repeat the steps above until the there’s no more character to add in the end.
• Display the total count in the end.

Below is the implementation of the above approach :

## C++

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function that counts all the ` `// sub-strings of length 'k' ` `// which have all identical characters ` `void` `solve(string s, ``int` `k) ` `{ ` `    ``// count of sub-strings, length, ` `    ``// initial position of sliding window ` `    ``int` `count = 0, length = 0, pos = 0; ` ` `  `    ``// map to store the frequency of ` `    ``// the characters of sub-string ` `    ``map<``char``, ``int``> m; ` ` `  `    ``for` `(``int` `i = 0; i < s.length(); i++) { ` ` `  `        ``// increase the frequency of the character ` `        ``// and length of the sub-string ` `        ``m[s[i]]++; ` `        ``length++; ` ` `  `        ``// if the length of the sub-string ` `        ``// is greater than K ` `        ``if` `(length > k) { ` ` `  `            ``// remove the character from ` `            ``// the beginning of sub-string ` `            ``m[s[pos++]]--; ` `            ``length--; ` `        ``} ` ` `  `        ``// if the length of the sub string ` `        ``// is equal to k and frequency of one ` `        ``// of its characters is equal to the ` `        ``// length of the sub-string ` `        ``// i.e. all the characters are same ` `        ``// increase the count ` `        ``if` `(length == k && m[s[i]] == length) ` `            ``count++; ` `    ``} ` ` `  `    ``// display the number ` `    ``// of valid sub-strings ` `    ``cout << count << endl; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string s = ``"aaaabbbccdddd"``; ` `    ``int` `k = 4; ` ` `  `    ``solve(s, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `    ``// Function that counts all the ` `    ``// sub-strings of length 'k' ` `    ``// which have all identical characters ` `    ``static` `void` `solve(String s, ``int` `k) ` `    ``{ ` `        ``// count of sub-strings, length, ` `        ``// initial position of sliding window ` `        ``int` `count = ``0``, length = ``0``, pos = ``0``; ` `     `  `        ``// map to store the frequency of ` `        ``// the characters of sub-string ` `        ``HashMap m =  ` `                            ``new` `HashMap(); ` `     `  `        ``for` `(``int` `i = ``0``; i < s.length(); i++)  ` `        ``{ ` `     `  `            ``// increase the frequency of the character ` `            ``// and length of the sub-string ` `            ``if``(m.containsKey(s.charAt(i))) ` `                ``m.put(s.charAt(i), m.get(s.charAt(i))+``1``); ` `            ``else` `                ``m.put(s.charAt(i), ``1``); ` `                 `  `            ``length++; ` `     `  `            ``// if the length of the sub-string ` `            ``// is greater than K ` `            ``if` `(length > k)  ` `            ``{ ` `     `  `                ``// remove the character from ` `                ``// the beginning of sub-string ` `                ``m.put(s.charAt(pos), m.get(s.charAt(pos)) -``1` `); ` `                ``pos++; ` `                ``length--; ` `            ``} ` `     `  `            ``// if the length of the sub string ` `            ``// is equal to k and frequency of one ` `            ``// of its characters is equal to the ` `            ``// length of the sub-string ` `            ``// i.e. all the characters are same ` `            ``// increase the count ` `            ``if` `(length == k && m.get(s.charAt(i)) == length) ` `                ``count++; ` `        ``} ` `     `  `        ``// display the number ` `        ``// of valid sub-strings ` `        ``System.out.println( count); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `         `  `        ``String s = ``"aaaabbbccdddd"``; ` `        ``int` `k = ``4``; ` `     `  `        ``solve(s, k); ` `    ``} ` `} ` ` `  `// This code is contributed by ihritik `

## Python 3

 `# Python3 implementation of above  ` `# approach ` ` `  `# Function that counts all the  ` `# sub-strings of length 'k'  ` `# which have all identical characters ` `def` `solve(s, k) : ` ` `  `    ``# count of sub-strings, length,  ` `    ``# initial position of sliding window  ` `    ``count, length, pos ``=` `0``, ``0``, ``0` ` `  `    ``# dictionary to store the frequency of  ` `    ``# the characters of sub-string  ` `    ``m ``=` `dict``.fromkeys(s,``0``) ` ` `  `    ``for` `i ``in` `range``(``len``(s)) : ` `         `  `        ``# increase the frequency of the character  ` `        ``# and length of the sub-string  ` `        ``m[s[i]] ``+``=` `1` `        ``length ``+``=` `1` ` `  `        ``# if the length of the sub-string  ` `        ``# is greater than K  ` `        ``if` `length > k : ` ` `  `            ``# remove the character from  ` `            ``# the beginning of sub-string ` `            ``m[s[pos]] ``-``=` `1` `            ``pos ``+``=` `1` `            ``length ``-``=` `1` ` `  `        ``# if the length of the sub string  ` `        ``# is equal to k and frequency of one  ` `        ``# of its characters is equal to the  ` `        ``# length of the sub-string  ` `        ``# i.e. all the characters are same  ` `        ``# increase the count  ` `        ``if` `length ``=``=` `k ``and` `m[s[i]] ``=``=` `length : ` `            ``count ``+``=` `1` ` `  `    ``# display the number  ` `    ``# of valid sub-strings ` `    ``print``(count) ` `             `  ` `  ` `  `# Driver code      ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``s ``=` `"aaaabbbccdddd"` `    ``k ``=` `4` ` `  `    ``# Function call ` `    ``solve(s, k) ` `                 `  `# This code is contributed by  ` `# ANKITRAI1 `

## C#

 `// C# implementation of above approach ` ` `  `using` `System; ` `using` `System.Collections.Generic; ` `class` `GFG ` `{ ` `    ``// Function that counts all the ` `    ``// sub-strings of length 'k' ` `    ``// which have all identical characters ` `    ``static` `void` `solve(``string` `s, ``int` `k) ` `    ``{ ` `        ``// count of sub-strings, length, ` `        ``// initial position of sliding window ` `        ``int` `count = 0, length = 0, pos = 0; ` `     `  `        ``// map to store the frequency of ` `        ``// the characters of sub-string ` `        ``Dictionary<``char``, ``int``> m =  ` `                            ``new` `Dictionary<``char``, ``int``>(); ` `     `  `        ``for` `(``int` `i = 0; i < s.Length; i++) { ` `     `  `            ``// increase the frequency of the character ` `            ``// and length of the sub-string ` `            ``if``(m.ContainsKey(s[i])) ` `                ``m[s[i]]++; ` `            ``else` `                ``m[s[i]] = 1; ` `                 `  `            ``length++; ` `     `  `            ``// if the length of the sub-string ` `            ``// is greater than K ` `            ``if` `(length > k) { ` `     `  `                ``// remove the character from ` `                ``// the beginning of sub-string ` `                ``m[s[pos]]--; ` `                ``pos++; ` `                ``length--; ` `            ``} ` `     `  `            ``// if the length of the sub string ` `            ``// is equal to k and frequency of one ` `            ``// of its characters is equal to the ` `            ``// length of the sub-string ` `            ``// i.e. all the characters are same ` `            ``// increase the count ` `            ``if` `(length == k && m[s[i]] == length) ` `                ``count++; ` `        ``} ` `     `  `        ``// display the number ` `        ``// of valid sub-strings ` `        ``Console.WriteLine(count); ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main () { ` `         `  `        ``string` `s = ``"aaaabbbccdddd"``; ` `        ``int` `k = 4; ` `     `  `        ``solve(s, k); ` `     `  `    ``} ` ` `  `} ` ` `  ` `  `// This code is contributed by ihritik `

## PHP

 ` ``\$k``)  ` `        ``{ ` ` `  `            ``// remove the character from ` `            ``// the beginning of sub-string ` `            ``\$m``[``\$s``[``\$pos``++]]--; ` `            ``\$length``--; ` `        ``} ` ` `  `        ``// if the length of the sub string ` `        ``// is equal to k and frequency of one ` `        ``// of its characters is equal to the ` `        ``// length of the sub-string ` `        ``// i.e. all the characters are same ` `        ``// increase the count ` `        ``if` `(``\$length` `== ``\$k` `&& ``\$m``[``\$s``[``\$i``]] == ``\$length``) ` `            ``\$count``++; ` `    ``} ` ` `  `    ``// display the number ` `    ``// of valid sub-strings ` `    ``echo` `\$count` `. ``"\n"``; ` `} ` ` `  `// Driver code ` `\$s` `= ``"aaaabbbccdddd"``; ` `\$k` `= 4; ` ` `  `solve(``\$s``, ``\$k``); ` ` `  `// This code is contributed  ` `// by ChitraNayal ` `?> `

Output:

```2
``` My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.