Number of Equal Count Substrings - Practice Coding Problems

Number of Equal Count Substrings - Problem

Imagine you're analyzing text patterns where balance matters. You have a string containing only lowercase English letters, and you need to find all substrings where each unique character appears exactly the same number of times.

Given a string s and an integer count, find all equal count substrings where every unique letter appears exactly count times. For example, in "aaabbb" with count = 3, the entire string is an equal count substring because both 'a' and 'b' appear exactly 3 times.

Goal: Return the total number of such balanced substrings.

Input: A string s and integer count
Output: Number of equal count substrings

Input & Output

example_1.py — Basic Case

$ Input: s = "aaabbbccc", count = 3

› Output: 3

💡 Note: Three valid substrings: "aaa" (a appears 3 times), "bbb" (b appears 3 times), and "ccc" (c appears 3 times). Each has exactly one unique character appearing exactly 3 times.

example_2.py — Mixed Characters

$ Input: s = "abab", count = 2

› Output: 1

💡 Note: Only one valid substring: "abab" where both 'a' and 'b' appear exactly 2 times each. Shorter substrings don't have the required count.

example_3.py — No Valid Substrings

$ Input: s = "abc", count = 2

› Output: 0

💡 Note: No substring can have any character appearing exactly 2 times since each character appears only once in the entire string.

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ count ≤ s.length
s consists of only lowercase English letters
All characters in a valid substring must appear exactly count times

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Valid substrings have predictable lengths: k unique chars × count occurrences each

Systematic Search

For each k from 1 to 26, use sliding window to find valid windows of length k×count

Window Validation

Check if current window has exactly k unique characters, each appearing exactly count times

Efficient Counting

Sliding window eliminates redundant work, achieving O(n) complexity

Key Takeaway

🎯 Key Insight: By recognizing that valid substrings have predictable lengths and using sliding windows for each possible unique character count, we achieve optimal O(n) time complexity instead of the naive O(n³) approach.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a sliding window approach for each possible number of unique characters (1-26). For k unique characters, valid substrings must have length exactly k×count. The algorithm runs in O(n) time by processing each character at most 26 times across all window sizes, making it significantly faster than the O(n³) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Fixed Unique Characters (Optimal)	O(26n) = O(n)	O(1)	Use sliding window technique for each possible number of unique characters
Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and check if each satisfies the equal count condition

Sliding Window with Fixed Unique Characters (Optimal) — Algorithm Steps

For each possible number of unique characters k (1 to 26)
Use sliding window of varying size with character frequency tracking
Expand window while maintaining at most k unique characters
When all k characters have exactly 'count' occurrences, increment result
Shrink window when we exceed k unique characters or any character exceeds 'count'

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Unique Count

For k=1,2,3...26 unique characters

Sliding Window

Expand/shrink window maintaining constraints

Check Validity

When window has k chars each with 'count' occurrences

Count Results

Accumulate valid windows across all k values

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int countWithExactlyKUnique(char* s, int k, int count) {
    int n = strlen(s);
    if (k * count > n) return 0;
    
    int result = 0;
    int left = 0;
    
    for (int right = 0; right < n; right++) {
        // For each position, check all possible windows ending here
        int freq[26] = {0};
        int uniqueCount = 0;
        
        // Build frequency map for current window
        for (int i = right; i >= left && (right - i + 1) <= k * count; i--) {
            if (freq[s[i] - 'a'] == 0) uniqueCount++;
            freq[s[i] - 'a']++;
            
            // Check if current window is valid
            if (uniqueCount == k && (right - i + 1) == k * count) {
                int valid = 1;
                for (int j = 0; j < 26; j++) {
                    if (freq[j] > 0 && freq[j] != count) {
                        valid = 0;
                        break;
                    }
                }
                if (valid) result++;
            }
            
            if (uniqueCount > k) break;
        }
    }
    
    return result;
}

int countEqualCountSubstrings(char* s, int count) {
    int total = 0;
    // Try all possible numbers of unique characters
    for (int k = 1; k <= 26; k++) {
        total += countWithExactlyKUnique(s, k, count);
    }
    return total;
}

int main() {
    char s[1001];
    int count;
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        strcpy(s, start);
    }
    scanf("%d", &count);
    printf("%d\n", countEqualCountSubstrings(s, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26n) = O(n)

We run sliding window algorithm for each of 26 possible unique character counts, each taking O(n) time

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 characters (constant space)

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Fixed Unique Characters (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler