Find Special Substring of Length K - Practice Coding Problems

Find Special Substring of Length K - Problem

String Easy

You're given a string s and an integer k. Your task is to find a special substring of exactly length k that meets these requirements:

The substring contains only one distinct character (like "aaa" or "bbb")
If there's a character immediately before the substring, it must be different from the substring's character
If there's a character immediately after the substring, it must be different from the substring's character

Goal: Return true if such a special substring exists, otherwise return false.

Example: In string "abaaacb" with k=3, the substring "aaa" at positions 2-4 is special because it's surrounded by different characters ('b' and 'c').

Input & Output

example_1.py — Basic Special Substring

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

› Output: true

💡 Note: The substring "aaa" at positions 2-4 consists of identical characters and is surrounded by different characters ('b' before and 'c' after).

example_2.py — No Valid Special Substring

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

› Output: false

💡 Note: No substring of length 2 consists of identical characters, so no special substring exists.

example_3.py — Edge Case at String End

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

› Output: true

💡 Note: The substring "cc" at the end consists of identical characters and is preceded by a different character 'b'.

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ k ≤ s.length
s consists of lowercase English letters only
k cannot exceed the length of the string

Visualization

Tap to expand

Understanding the Visualization

Scan the sequence

Move through each tile, tracking consecutive identical colors

Detect uniform blocks

When we find k or more consecutive identical tiles, check boundaries

Validate boundaries

Ensure the block is surrounded by different colored tiles

Return result

True if we find any valid special block, false otherwise

Key Takeaway

🎯 Key Insight: We can solve this efficiently by tracking consecutive character runs and checking boundary conditions only when we find a potential match, achieving O(n) time complexity.

Asked in

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

The optimal solution uses a single pass approach with state tracking to identify consecutive identical characters. When we find a run of ≥ k identical characters, we check the boundary conditions to validate if it forms a special substring. This achieves O(n) time complexity and O(1) space complexity, making it efficient for large strings.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Substring)	O(n*k)	O(1)	Check every possible substring of length k for the special conditions
Single Pass with State Tracking (Optimal)	O(n)	O(1)	Track consecutive character runs and validate special substrings in one pass

Brute Force (Check Every Substring) — Algorithm Steps

Iterate through each possible starting position (0 to n-k)
For each position, extract the k-length substring
Check if all characters in the substring are identical
Check boundary conditions (previous and next characters)
Return true if any substring satisfies all conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Extract k-length substring and check uniformity

Check boundaries

Verify that adjacent characters are different

Move to next position

Repeat process for all possible starting positions

Code -

solution.c — C

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

bool hasSpecialSubstring(char* s, int k) {
    int n = strlen(s);
    if (n < k) return false;
    
    for (int i = 0; i <= n - k; i++) {
        char ch = s[i];
        bool isUniform = true;
        
        // Check if all characters are the same
        for (int j = i; j < i + k; j++) {
            if (s[j] != ch) {
                isUniform = false;
                break;
            }
        }
        
        if (!isUniform) continue;
        
        // Check boundary conditions
        bool validBefore = (i == 0) || (s[i-1] != ch);
        bool validAfter = (i + k == n) || (s[i+k] != ch);
        
        if (validBefore && validAfter) {
            return true;
        }
    }
    
    return false;
}

int main() {
    char s[1000];
    int k;
    scanf("%s %d", s, &k);
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    printf("%s\n", hasSpecialSubstring(s, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We check up to n-k+1 substrings, each requiring k character comparisons

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for indexing and comparison

✓ Linear Space

24.7K Views

Medium Frequency

~12 min Avg. Time

892 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