Codestin Search App

Count Substrings With K-Frequency Characters I - Problem

You're given a string s and an integer k. Your task is to count how many substrings of s contain at least one character that appears at least k times within that substring.

A substring is a contiguous sequence of characters within a string. For example, in the string "hello", some substrings are "h", "he", "ell", "hello", etc.

Example: If s = "abcab" and k = 2, we need to find substrings where at least one character appears 2 or more times. The substring "abcab" contains 'a' twice and 'b' twice, so it qualifies. The substring "bcab" contains 'b' twice, so it also qualifies.

Can you efficiently count all such valid substrings?

Input & Output

example_1.py — Basic Case

$ Input: s = "abcab", k = 2

› Output: 4

💡 Note: The valid substrings are: "abca" (a appears 2 times), "bcab" (b appears 2 times), "abcab" (both a and b appear 2 times), "cab" contains "ab" where both appear in the full context. Total count: 4

example_2.py — Single Character

$ Input: s = "aaaa", k = 3

› Output: 3

💡 Note: Valid substrings: "aaa" (positions 0-2), "aaa" (positions 1-3), and "aaaa" (positions 0-3). Character 'a' appears at least 3 times in each of these substrings.

example_3.py — No Valid Substrings

$ Input: s = "abcde", k = 2

› Output: 0

💡 Note: No character appears more than once in any substring, so no substring satisfies the condition of having at least one character appear k=2 or more times.

Visualization

Tap to expand

Understanding the Visualization

Set up investigation

Position your magnifying glass at the start of the evidence

Expand the view

Gradually expand your view to include more characters, keeping track of frequency

Found significant evidence

Once you find a character appearing k times, you know this section and all extensions are valid

Count efficiently

Instead of checking each extension individually, count them all at once

Move to next position

Start a new investigation from the next position

Key Takeaway

🎯 Key Insight: Once any character reaches frequency k in a substring, all longer substrings extending from that point will also be valid, allowing us to count them efficiently rather than checking each one individually.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for each starting position × O(n) positions, but with early termination optimization

⚠ Quadratic Growth

Space Complexity

O(1)

Hash map stores at most 26 different characters (constant space)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 3000
1 ≤ k ≤ s.length
s consists of only lowercase English letters
Time limit: 2 seconds

Asked in

f Meta 15 G Google 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses a sliding window technique with hash tables to count substrings efficiently. Instead of checking every substring individually, we expand a window from each starting position and use the key insight that once any character reaches frequency k, all longer substrings from that starting position will also be valid. This reduces time complexity from O(n³) to O(n²) with early termination optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and check each one individually
Optimized Hash Table (Two Pointers + Sliding Window)	O(n²)	O(1)	Use sliding window to efficiently count valid substrings without redundant calculations

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible starting positions (0 to n-1)
For each starting position, generate all possible ending positions
For each substring, count character frequencies using a hash map
Check if any character frequency is >= k
Increment counter if condition is met

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first character

Begin checking substrings starting from index 0

Expand substring

Gradually expand the substring by including more characters

Count frequencies

For each substring, count how many times each character appears

Check condition

Verify if any character appears at least k times

Code -

solution.c — C

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

int countSubstrings(char* s, int k) {
    int n = strlen(s);
    int count = 0;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count frequency of each character in substring s[i:j+1]
            int freq[256] = {0}; // ASCII table size
            for (int l = i; l <= j; l++) {
                freq[(int)s[l]]++;
            }
            
            // Check if any character appears at least k times
            int found = 0;
            for (int c = 0; c < 256; c++) {
                if (freq[c] >= k) {
                    count++;
                    found = 1;
                    break;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char s[1001];
    int k;
    scanf("%s %d", s, &k);
    printf("%d\n", countSubstrings(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for generating all substrings × O(n) for counting frequencies in each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a fixed-size hash map for character frequencies (at most 26 characters)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 3000
1 ≤ k ≤ s.length
s consists of only lowercase English letters
Time limit: 2 seconds

28.4K Views

Medium Frequency

~15 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler