# Sub-strings of length K containing same character

• Difficulty Level : Medium
• Last Updated : 06 May, 2021

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```

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``?>`

## Javascript

 ``
Output:
`2`

My Personal Notes arrow_drop_up