Count Complete Substrings - Practice Coding Problems

Count Complete Substrings - Problem

You have been given a string word and an integer k. Your task is to find all complete substrings within the word and count how many exist.

A substring is considered complete if it satisfies two strict conditions:

Character Frequency: Each character in the substring must appear exactly k times
Adjacent Character Constraint: Any two adjacent characters in the substring must have an alphabetical distance of at most 2 (e.g., 'a' and 'c' are valid neighbors, but 'a' and 'd' are not)

For example, if word = "aaabbbccc" and k = 3, the substring "aaabbb" would be complete because each character appears exactly 3 times and 'a' and 'b' are adjacent in the alphabet (distance = 1 ≤ 2).

Goal: Return the total number of complete substrings in the given word.

Input & Output

example_1.py — Basic Complete Substring

$ Input: word = "aaabbbccc", k = 3

› Output: 1

💡 Note: The only complete substring is "aaabbbccc" itself. Each character (a, b, c) appears exactly 3 times, and the adjacency constraint is satisfied since |a-b| = 1 ≤ 2 and |b-c| = 1 ≤ 2.

example_2.py — Multiple Valid Substrings

$ Input: word = "aabbcc", k = 2

› Output: 3

💡 Note: Three complete substrings exist: "aabb" (a appears 2 times, b appears 2 times), "bbcc" (b appears 2 times, c appears 2 times), and "aabbcc" (each character appears exactly 2 times).

example_3.py — Adjacency Constraint Violation

$ Input: word = "aaafff", k = 3

› Output: 0

💡 Note: No complete substrings exist because |a-f| = 5 > 2, violating the adjacency constraint. Even though each character appears 3 times in the full string, they cannot form a valid complete substring.

Constraints

1 ≤ word.length ≤ 10⁵
1 ≤ k ≤ word.length
word consists only of lowercase English letters
Adjacent characters in complete substrings must have alphabetical distance ≤ 2

Visualization

Tap to expand

Understanding the Visualization

Identify Segments

Split string where adjacency constraint breaks (|char_i - char_{i-1}| > 2)

Process Each Segment

Within each valid segment, use sliding window technique

Try All Character Counts

For 1 to 26 unique characters, maintain window of size uniqueChars × k

Count Valid Windows

Track character frequencies and count when all chars appear exactly k times

Key Takeaway

🎯 Key Insight: By segmenting the string based on adjacency constraints and then applying sliding window within each valid segment, we achieve optimal O(n) time complexity while correctly handling both character frequency and adjacency requirements.

Asked in

G Google 32 a Amazon 28 f Meta 25 ⊞ Microsoft 18

The optimal approach uses a sliding window technique with segmentation. First, break the string into segments where the adjacency constraint holds (adjacent characters differ by ≤ 2). Then, within each segment, use a sliding window to find substrings where all characters appear exactly k times. The key insight is trying all possible unique character counts (1-26) and maintaining a window of size uniqueChars × k. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring for both character count and adjacency constraints
Optimized Sliding Window (Optimal)	O(n * 26)	O(1)	Break string into valid segments, then use sliding window with hash map within each segment

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, check if adjacent characters satisfy distance constraint
Count frequency of each character in valid substrings
Verify that all characters appear exactly k times
Increment counter for valid complete substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Use nested loops to create all possible substrings

Check Adjacency

Verify that adjacent characters have distance ≤ 2

Count Frequencies

Count each character and verify all appear exactly k times

Increment Counter

Add to result if both conditions are satisfied

Code -

solution.c — C

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

int isValidAdjacency(char* s, int len) {
    for (int i = 1; i < len; i++) {
        if (abs(s[i] - s[i-1]) > 2) {
            return 0;
        }
    }
    return 1;
}

int hasExactKFrequency(char* s, int len, int k) {
    int count[26] = {0};
    for (int i = 0; i < len; i++) {
        count[s[i] - 'a']++;
    }
    for (int i = 0; i < 26; i++) {
        if (count[i] > 0 && count[i] != k) {
            return 0;
        }
    }
    return 1;
}

int countCompleteSubstrings(char* word, int k) {
    int n = strlen(word);
    int result = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + k; j <= n; j += k) {
            if (isValidAdjacency(word + i, j - i) && 
                hasExactKFrequency(word + i, j - i, k)) {
                result++;
            }
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counting

✓ Linear Space

26.8K Views

Medium-High Frequency

~25 min Avg. Time

856 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