Count Beautiful Substrings II

Count Beautiful Substrings II - Problem

Hash Table Math String Number Theory Prefix Sum Hard

You are given a string s and a positive integer k.

Let vowels and consonants be the number of vowels and consonants in a string.

A string is beautiful if:

vowels == consonants
(vowels * consonants) % k == 0, which means the multiplication of vowels and consonants is divisible by k

Return the number of non-empty beautiful substrings in the given string s.

A substring is a contiguous sequence of characters in a string.

Vowel letters in English are 'a', 'e', 'i', 'o', and 'u'.

Consonant letters in English are every letter except vowels.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Beautiful substrings are "baey" (V=2, C=2, 2*2=4, 4%2=0) and "aey" (V=2, C=1... wait, this doesn't work). Actually: "ae" (V=2, C=0) fails balance. Let me recalculate: "ba" (V=1, C=1, 1*1=1, 1%2≠0), "bae" (V=2, C=1) fails balance. The beautiful substrings are "baey" (V=2, C=2, 2*2%2=0) and "aeyh" (V=2, C=2, 2*2%2=0).

Example 2 — Single Character

$ Input: s = "a", k = 1

› Output: 0

💡 Note: Single vowel "a" has V=1, C=0, so vowels ≠ consonants. No beautiful substrings possible.

Example 3 — Minimum Beautiful

$ Input: s = "ab", k = 1

› Output: 1

💡 Note: Substring "ab" has V=1, C=1 (balanced) and 1*1=1, 1%1=0 (divisible). This is beautiful.

Constraints

1 ≤ s.length ≤ 5 × 10⁴
1 ≤ k ≤ 1000
s consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is to use prefix differences to track vowel-consonant balance and apply number theory for efficient divisibility checking. The optimal approach uses a hash map to store states (difference, position mod √k) achieving O(n√k) time complexity with O(n√k) space.

Common Approaches

✓ Memoization

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

Advanced Prefix Sum with Hash Map

⏱️ Time: O(n × √k) Space: O(n × √k)

Transform the problem into finding prefix differences where vowels-consonants equals 0, and use number theory to optimize divisibility checks with mathematical factorization.

Brute Force - Check All Substrings

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

Generate all possible substrings and for each one, count vowels and consonants, then check if they're equal and their product is divisible by k.

Optimized with Number Theory

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

Instead of recounting characters for each substring, use prefix sums to get vowel/consonant counts in O(1). Also optimize the divisibility check using mathematical properties.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_STATES 100000

typedef struct {
    int diff;
    int posMod;
    int count;
} State;

State states[MAX_STATES];
int stateCount = 0;

int isVowel(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}

int findState(int diff, int posMod) {
    for (int i = 0; i < stateCount; i++) {
        if (states[i].diff == diff && states[i].posMod == posMod) {
            return i;
        }
    }
    return -1;
}

void addState(int diff, int posMod) {
    int idx = findState(diff, posMod);
    if (idx == -1) {
        states[stateCount].diff = diff;
        states[stateCount].posMod = posMod;
        states[stateCount].count = 1;
        stateCount++;
    } else {
        states[idx].count++;
    }
}

int solution(char* s, int k) {
    int n = strlen(s);
    
    // Find square root of k for optimization
    int sqrtK = 1;
    while (sqrtK * sqrtK < k) {
        sqrtK += 1;
    }
    
    // Initialize with base case
    stateCount = 0;
    addState(0, 0);
    
    int diff = 0;  // vowels - consonants
    int count = 0;
    
    for (int i = 0; i < n; i++) {
        // Update difference
        if (isVowel(s[i])) {
            diff += 1;
        } else {
            diff -= 1;
        }
        
        // Check for beautiful substrings ending at position i
        int posMod = (i + 1) % sqrtK;
        int idx = findState(diff, posMod);
        
        if (idx != -1) {
            count += states[idx].count;
        }
        
        // Add current state
        addState(diff, posMod);
    }
    
    return count;
}

int main() {
    char s[1000];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    printf("%d\n", solution(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

284 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