Codestin Search App

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.

Constraints

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

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!

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
✓ 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)	O(n³)	O(1)	Check every possible substring by counting vowels and consonants

Optimized with Prefix Sum & Hash Map — Algorithm Steps

Convert vowels to +1 and consonants to -1
Use prefix sum to track running difference
For each position, look for previous positions with same difference and valid divisibility
Use hash map to store frequency of each (difference, remainder) pair
Count valid beautiful substrings efficiently

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Start

Fix starting position and reset counters

Extend Right

Extend to the right, updating vowel/consonant counts

Check Balance

At each position, check if current substring is beautiful

Count Valid

Increment counter for beautiful substrings

Code -

solution.c — C

#include <stdbool.h>
bool 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++) {
        int vowelCount = 0;
        int consonantCount = 0;
        
        for (int j = i; j < n; j++) {
            if (isVowel(s[j])) {
                vowelCount++;
            } else {
                consonantCount++;
            }
            
            if (vowelCount == consonantCount &&
                vowelCount > 0 &&
                (vowelCount * consonantCount) % k == 0) {
                count++;
            }
        }
    }
    
    return count;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Optimized with Prefix Sum & Hash Map — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler