Count Beautiful Substrings I - Practice Coding Problems

Count Beautiful Substrings I - Problem

Hash Table Math String Enumeration Number Theory Prefix Sum Medium

🎨 Count Beautiful Substrings I

Imagine you're analyzing text patterns where balance and divisibility create beauty! You're given a string s and a positive integer k.

A substring is considered beautiful if it satisfies two elegant conditions:

Perfect Balance: The number of vowels equals the number of consonants
Divisibility Magic: The product of vowel count and consonant count is divisible by k

Your mission: Count all non-empty beautiful substrings in the given string.

Note: Vowels are 'a', 'e', 'i', 'o', 'u' and consonants are all other letters.

Example: In string "baeyh" with k=2, the substring "baey" has 2 vowels ('a','e') and 2 consonants ('b','y'), so 2×2=4 which is divisible by 2. Beautiful! ✨

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Beautiful substrings are "baey" (vowels=2, consonants=2, 2×2=4, 4%2=0) and "b" is not valid since it needs equal vowels and consonants. The substring "aeyh" gives vowels=2, consonants=2, and 2×2=4 which is divisible by 2.

example_2.py — Single Character

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

› Output: 3

💡 Note: The beautiful substrings are: "ab" (V:1, C:1, 1×1=1, 1%1=0), "bb" is not valid (no vowels), "ba" (V:1, C:1, 1×1=1, 1%1=0), and "abba" (V:2, C:2, 2×2=4, 4%1=0). Total: 3 beautiful substrings.

example_3.py — Edge Case

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

› Output: 0

💡 Note: All characters are consonants, so no substring can have equal vowels and consonants. Therefore, there are 0 beautiful substrings.

Visualization

Tap to expand

Understanding the Visualization

Identify Characters

Classify each letter as vowel (colorful) or consonant (grayscale)

Check Balance

Ensure equal number of vowels and consonants

Verify Divisibility

Confirm their product fits evenly into k-sized display cases

Count Beautiful

Increment counter for each valid arrangement

Key Takeaway

🎯 Key Insight: Transform the problem into finding balanced substrings where vowel×consonant products fit perfectly into k-sized containers!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass through string, but checking divisibility condition still requires nested logic

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store prefix sum states

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 1000
1 ≤ k ≤ 1000
s consists of only lowercase English letters
Vowels are exactly: 'a', 'e', 'i', 'o', 'u'

Asked in

G Google 25 f Meta 18 ⊞ Microsoft 12 a Amazon 8

The optimal approach uses an optimized nested loop strategy. For each starting position, we extend rightward while maintaining running counts of vowels and consonants. This eliminates redundant character counting and achieves O(n²) time complexity with O(1) space. The key insight is to incrementally build substrings rather than examining each one from scratch.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible substring by counting vowels and consonants
Optimized with Prefix Sum & Hash Map	O(n²)	O(n)	Use prefix sums and hash map to efficiently track vowel-consonant balance

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all possible starting positions
For each start, try all possible ending positions
Count vowels and consonants in current substring
Check if vowels == consonants and (vowels × consonants) % k == 0
Increment counter if both conditions are met

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Fix starting position i

End Position

Try all ending positions j >= i

Count Characters

Count vowels and consonants in substring s[i:j+1]

Check Conditions

Verify balance and divisibility

Code -

solution.c — C

#include <string.h>
int isVowel(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}

int beautifulSubstrings(char* s, int k) {
    int count = 0;
    int n = strlen(s);
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int vowelCount = 0;
            int consonantCount = 0;
            
            for (int idx = i; idx <= j; idx++) {
                if (isVowel(s[idx])) {
                    vowelCount++;
                } else {
                    consonantCount++;
                }
            }
            
            if (vowelCount == consonantCount && 
                vowelCount > 0 && 
                (vowelCount * consonantCount) % k == 0) {
                count++;
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops for start/end positions (O(n²)) and counting characters in each substring (O(n))

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
1 ≤ k ≤ 1000
s consists of only lowercase English letters
Vowels are exactly: 'a', 'e', 'i', 'o', 'u'

24.5K Views

Medium Frequency

~25 min Avg. Time

867 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

🎨 Count Beautiful Substrings I

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler