Longest Substring with At Least K Repeating Characters

Longest Substring with At Least K Repeating Characters - Problem

Given a string s and an integer k, return the length of the longest substring of s such that the frequency of each character in this substring is greater than or equal to k.

If no such substring exists, return 0.

Note: A substring is a contiguous sequence of characters within a string.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: The longest substring is "aaa" where character 'a' appears 3 times, which meets the requirement k=3.

Example 2 — No Valid Substring

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

› Output: 5

💡 Note: The longest substring is "ababb" where 'a' appears 2 times and 'b' appears 3 times, both ≥ k=2.

Example 3 — Impossible Case

$ Input: s = "abc", k = 4

› Output: 0

💡 Note: No character appears 4 times since the string length is only 3, so return 0.

Constraints

1 ≤ s.length ≤ 10⁴
s consists of only lowercase English letters
1 ≤ k ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 f Facebook 22 M Microsoft 18

The key insight is that if a character appears less than k times in the entire string, it cannot be part of any valid substring. The best approach uses divide and conquer to split at invalid characters or sliding window with fixed unique character counts. Time: O(n), Space: O(1)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n³) Space: O(1)

Generate every possible substring, count the frequency of each character in that substring, and check if all frequencies are at least k. Keep track of the maximum length found.

Divide and Conquer

⏱️ Time: O(n²) Space: O(n)

If a character appears less than k times in the entire string, it cannot be part of any valid substring. Use this insight to split the string at such characters and recursively solve subproblems.

Sliding Window with Unique Character Count

⏱️ Time: O(n) Space: O(1)

For each possible number of unique characters (1 to 26), use a sliding window to find the longest substring with exactly that many unique characters where each appears at least k times.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

int* solution(int board[][MAX_SIZE], int m, int n, char pattern[][MAX_SIZE][10], int p, int q) {
    int* result = malloc(2 * sizeof(int));
    result[0] = -1;
    result[1] = -1;
    
    if (p > m || q > n) {
        return result;
    }
    
    for (int r = 0; r <= m - p; r++) {
        for (int c = 0; c <= n - q; c++) {
            int letterToDigit[26];
            int digitToLetter[10];
            int letterUsed[26] = {0};
            int digitUsed[10] = {0};
            
            for (int k = 0; k < 26; k++) letterToDigit[k] = -1;
            for (int k = 0; k < 10; k++) digitToLetter[k] = -1;
            
            int valid = 1;
            for (int i = 0; i < p && valid; i++) {
                for (int j = 0; j < q && valid; j++) {
                    char patternCell = pattern[i][j][0];
                    int boardCell = board[r + i][c + j];
                    
                    if (isdigit(patternCell)) {
                        int digit = patternCell - '0';
                        if (digit != boardCell) {
                            valid = 0;
                        }
                    } else {
                        int letterIdx = patternCell - 'a';
                        if (letterUsed[letterIdx]) {
                            if (letterToDigit[letterIdx] != boardCell) {
                                valid = 0;
                            }
                        } else {
                            if (digitUsed[boardCell]) {
                                if (digitToLetter[boardCell] != letterIdx) {
                                    valid = 0;
                                }
                            } else {
                                letterToDigit[letterIdx] = boardCell;
                                digitToLetter[boardCell] = letterIdx;
                                letterUsed[letterIdx] = 1;
                                digitUsed[boardCell] = 1;
                            }
                        }
                    }
                }
            }
            
            if (valid) {
                result[0] = r;
                result[1] = c;
                return result;
            }
        }
    }
    
    return result;
}

int parseBoard(const char* str, int board[][MAX_SIZE]) {
    int rows = 0;
    const char* ptr = str + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int cols = 0;
            while (*ptr && *ptr != ']') {
                if (isdigit(*ptr)) {
                    board[rows][cols++] = *ptr - '0';
                }
                ptr++;
            }
            rows++;
        }
        ptr++;
    }
    return rows;
}

int parsePattern(const char* str, char pattern[][MAX_SIZE][10]) {
    int rows = 0;
    const char* ptr = str + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            int cols = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr == '"') {
                    ptr++;
                    pattern[rows][cols][0] = *ptr;
                    pattern[rows][cols][1] = '\0';
                    cols++;
                    ptr++; // Skip the character
                    if (*ptr == '"') ptr++; // Skip closing quote
                }
                ptr++;
            }
            rows++;
        }
        ptr++;
    }
    return rows;
}

int main() {
    char line[10000];
    int board[MAX_SIZE][MAX_SIZE];
    char pattern[MAX_SIZE][MAX_SIZE][10];
    
    fgets(line, sizeof(line), stdin);
    int m = parseBoard(line, board);
    int n = 0;
    for (int i = 0; i < MAX_SIZE && board[0][i] != 0; i++) n++;
    
    fgets(line, sizeof(line), stdin);
    int p = parsePattern(line, pattern);
    int q = 0;
    for (int i = 0; i < MAX_SIZE && pattern[0][i][0] != '\0'; i++) q++;
    
    int* result = solution(board, m, n, pattern, p, q);
    printf("[%d,%d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

180.5K Views

Medium Frequency

~25 min Avg. Time

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