Longest Substring with At Least K Repeating Characters

Longest Substring with At Least K Repeating Characters - Problem

You are given a string s and an integer k. Your task is to find the length of the longest substring where every character appears at least k times.

Think of it as finding the most "balanced" part of the string where no character is underrepresented. For example, in the string "aaabbb" with k=2, both 'a' and 'b' appear 3 times, so the entire string qualifies. However, in "ababbc" with k=2, the character 'c' only appears once, so we need to find substrings that exclude it.

Return the length of the longest valid substring, or 0 if no such substring exists.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: The longest substring is "aaa" where 'a' appears 3 times, which satisfies k=3. The substring "bb" only has 'b' appearing 2 times, which is less than k=3.

example_2.py — No Valid Substring

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

› Output: 5

💡 Note: The longest substring is "ababb" where both 'a' and 'b' appear at least 2 times (a:2, b:3). The character 'c' only appears once, so it cannot be part of any valid substring.

example_3.py — Entire String Valid

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

› Output: 6

💡 Note: The entire string is valid because both 'a' and 'b' appear exactly 3 times, which meets the requirement k=3.

Constraints

1 ≤ s.length ≤ 10⁴
s consists of only lowercase English letters
1 ≤ k ≤ 10⁵
Note: k can be larger than the string length

Visualization

Tap to expand

Understanding the Visualization

Survey All Members

Count how many members of each type are available for the event

Identify Exclusions

Mark member types that don't meet the minimum requirement as invalid

Divide Groups

Split the member list around invalid types, creating separate valid groups

Optimize Each Group

Recursively find the largest valid group within each segment

Key Takeaway

🎯 Key Insight: Characters that don't meet the frequency requirement act as natural dividers, allowing us to solve smaller subproblems independently and find the optimal solution efficiently.

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal approach uses divide and conquer by recognizing that characters appearing less than k times cannot be part of any valid substring. We recursively split the string around these invalid characters and solve each valid segment independently, achieving efficient performance in most practical cases.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Generate all possible substrings and check each one for the k-frequency requirement
Divide and Conquer	O(n² log n)	O(n)	Recursively split the string around characters that appear less than k times

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, count character frequencies using a hash map
Check if all characters in the substring appear at least k times
Keep track of the maximum length found so far
Return the maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Start with all substrings beginning at index 0

Count Characters

For each substring, count character frequencies

Validate

Check if all characters meet the k-frequency requirement

Track Maximum

Keep track of the longest valid substring found

Code -

solution.c — C

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

int longestSubstring(char* s, int k) {
    int n = strlen(s);
    int maxLength = 0;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Count character frequencies for substring s[i..j]
            int charCount[26] = {0};
            for (int l = i; l <= j; l++) {
                charCount[s[l] - 'a']++;
            }
            
            // Check if all characters appear at least k times
            int valid = 1;
            for (int l = i; l <= j; l++) {
                if (charCount[s[l] - 'a'] < k) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid) {
                int length = j - i + 1;
                if (length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    char s[500];
    int k;
    sscanf(line, "%s %d", s, &k);
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    printf("%d\n", longestSubstring(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to count characters for each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a fixed-size character count array (at most 26 for lowercase letters)

✓ Linear Space

58.0K Views

Medium-High Frequency

~25 min Avg. Time

2.2K 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

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler