Find K-Length Substrings With No Repeated Characters

Find K-Length Substrings With No Repeated Characters - Problem

Given a string s and an integer k, you need to find how many substrings of length k exist that contain all unique characters (no repeated characters).

A substring is a contiguous sequence of characters within a string. For example, in the string "abc", the substrings of length 2 are "ab" and "bc".

Your task: Count all substrings of exactly length k where every character appears at most once.

Example: If s = "havefunonleetcode" and k = 5, then substrings like "havef" (has repeated characters) don't count, but "vefun" would count if all characters are unique.

Input & Output

example_1.py — Basic Case

$ Input: s = "havefunonleetcode", k = 5

› Output: 6

💡 Note: The 6 substrings of length 5 with no repeated characters are: "havef", "avefu", "vefun", "efuno", "funon", "nonle". Note that "onlee" has repeated 'e' so it doesn't count.

example_2.py — No Valid Substrings

$ Input: s = "home", k = 5

› Output: 0

💡 Note: Since k=5 is greater than the length of string "home" (which is 4), there are no substrings of length 5, so the answer is 0.

example_3.py — All Characters Repeated

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

› Output: 0

💡 Note: All possible substrings of length 2 are "aa", "aa", "aa". Each contains repeated character 'a', so none are valid.

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ k ≤ s.length
s consists of lowercase English letters only
The string may contain repeated characters

Visualization

Tap to expand

Understanding the Visualization

Position the magnifying glass

Start with the magnifying glass over the first k letters

Count unique letters

Use a counter to track each letter type under the glass

Check if valid

If counter shows k different letters, all are unique - increment result

Slide the glass

Move glass one position right: remove leftmost letter from counter, add new rightmost letter

Repeat until end

Continue sliding and checking until glass reaches the end

Key Takeaway

🎯 Key Insight: The sliding window approach transforms an O(n×k) problem into O(n) by reusing character frequency information as we slide the window, rather than recounting characters for each new position.

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a sliding window approach with hash map to track character frequencies in O(n) time. Instead of checking each substring independently, we maintain a window of size k and efficiently update character counts as we slide the window across the string. The key insight is that if the hash map size equals k, then all characters in the current window are unique.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Substring)	O(n * k)	O(k)	Check each k-length substring individually for duplicate characters
Sliding Window with Hash Map (Optimal)	O(n)	O(min(k, σ))	Use sliding window technique with character frequency tracking

Brute Force (Check Every Substring) — Algorithm Steps

Iterate through all possible starting positions (0 to n-k)
For each starting position, extract substring of length k
Check if substring has all unique characters using a set
If unique, increment counter
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Extract substring of length k starting at index 0

Check uniqueness

Use a set to verify all characters are unique

Move to next position

Slide to next starting position and repeat

Continue until end

Process all possible k-length substrings

Code -

solution.c — C

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

bool hasUniqueChars(char* str, int k) {
    bool seen[256] = {false};
    for (int i = 0; i < k; i++) {
        if (seen[(unsigned char)str[i]]) {
            return false;
        }
        seen[(unsigned char)str[i]] = true;
    }
    return true;
}

int numKLenSubstrNoRepeats(char* s, int k) {
    int n = strlen(s);
    if (k > n) {
        return 0;
    }
    
    int count = 0;
    
    // Check each possible substring of length k
    for (int i = 0; i <= n - k; i++) {
        if (hasUniqueChars(s + i, k)) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char s[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    scanf("%d", &k);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = 0;
    }
    
    printf("%d\n", numKLenSubstrNoRepeats(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

We check n-k+1 substrings, each requiring O(k) time to verify uniqueness

✓ Linear Growth

Space Complexity

O(k)

We need a set of size at most k to check for duplicates in each substring

✓ Linear Space

42.4K Views

High Frequency

~15 min Avg. Time

1.8K 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 Every Substring) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler