Count Complete Substrings

Count Complete Substrings - Problem

You are given a string word and an integer k.

A substring s of word is complete if:

Each character in s occurs exactly k times.
The difference between two adjacent characters is at most 2. That is, for any two adjacent characters c1 and c2 in s, the absolute difference in their positions in the alphabet is at most 2.

Return the number of complete substrings of word.

A substring is a non-empty contiguous sequence of characters in a string.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Complete substrings: "aaabbb" (a:3, b:3), "bbbccc" (b:3, c:3), "aaabbbccc" (a:3, b:3, c:3). All satisfy adjacency rule since |a-b|=1≤2 and |b-c|=1≤2.

Example 2 — No Valid Substrings

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

› Output: 0

💡 Note: No substring has each character appearing exactly 2 times. The string has 3 of each character, which doesn't match k=2.

Example 3 — Adjacency Violation

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

› Output: 0

💡 Note: Although "aaa" and "fff" individually have characters appearing 3 times, |a-f|=5>2 violates adjacency rule, so no complete substrings exist.

Constraints

1 ≤ word.length ≤ 1000
1 ≤ k ≤ word.length
word consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 10

The key insight is to split the string into segments where adjacency constraints are satisfied, then use sliding window technique to efficiently find substrings with exact character frequencies. The optimal approach uses sliding window with frequency tracking achieving O(n × 26) time and O(1) space complexity.

Common Approaches

✓ Brute Force

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

Generate all possible substrings and check if each one satisfies both the frequency condition (each character appears exactly k times) and the adjacency condition (adjacent characters differ by at most 2 in alphabet).

Optimized Sliding Window

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

First split the string into segments where adjacent characters differ by at most 2. Then for each segment, use sliding window to find substrings where each character appears exactly k times.

Brute Force — Algorithm Steps

Generate all possible substrings
For each substring, check adjacency condition
Count character frequencies and verify each appears exactly k times
Count valid substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible contiguous substrings

Check Conditions

Validate adjacency and frequency rules

Count Valid

Count substrings that satisfy both conditions

Code -

solution.c — C

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

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

bool hasExactFrequencies(char* s, int len, int k) {
    int freq[26] = {0};
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0 && freq[i] != k) {
            return false;
        }
    }
    return true;
}

int solution(char* word, int k) {
    int n = strlen(word);
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int len = j - i;
            if (len % k == 0) {
                char substring[len + 1];
                strncpy(substring, word + i, len);
                substring[len] = '\0';
                if (isValidAdjacency(substring, len) && hasExactFrequencies(substring, len, k)) {
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char word[1001];
    int k;
    fgets(word, sizeof(word), stdin);
    word[strcspn(word, "\n")] = 0;
    scanf("%d", &k);
    
    int result = solution(word, k);
    printf("%d\n", result);
    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 frequency counting

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

245 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler