Count Sorted Vowel Strings - Practice Coding Problems

Count Sorted Vowel Strings - Problem

Imagine you're creating a special dictionary where all words must follow very specific rules! 📖

Given an integer n, you need to find how many strings of length n can be formed using only vowels (a, e, i, o, u) where the vowels appear in lexicographically sorted order.

What does lexicographically sorted mean? It means each character must be the same as or come before the next character in alphabetical order. For example:

✅ "aei" is valid (a ≤ e ≤ i)
✅ "aaa" is valid (all same characters)
❌ "aie" is invalid (i > e)

Goal: Count all possible valid vowel strings of length n.

Example: For n=2, valid strings are: "aa", "ae", "ai", "ao", "au", "ee", "ei", "eo", "eu", "ii", "io", "iu", "oo", "ou", "uu" → Total: 15

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 5

💡 Note: For n=1, we can have 5 single-character strings: "a", "e", "i", "o", "u". All are lexicographically sorted by definition.

example_2.py — Medium Case

$ Input: n = 2

› Output: 15

💡 Note: Valid strings: "aa", "ae", "ai", "ao", "au" (5 starting with 'a'), "ee", "ei", "eo", "eu" (4 starting with 'e'), "ii", "io", "iu" (3 starting with 'i'), "oo", "ou" (2 starting with 'o'), "uu" (1 starting with 'u'). Total: 5+4+3+2+1 = 15.

example_3.py — Larger Case

$ Input: n = 33

› Output: 66045

💡 Note: For larger n, the pattern continues exponentially. Each position allows us to choose from remaining vowels, creating a combinatorial explosion that our DP solution handles efficiently.

Constraints

1 ≤ n ≤ 50
Answer will fit in a 32-bit integer
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Start with foundation

At length 1, we can use any of the 5 vowels as our foundation

Build upwards with restrictions

Each new level can only use vowels >= the previous level

Count all valid towers

DP efficiently counts all possible tower configurations

Sum the possibilities

Final answer is the total number of valid n-height towers

Key Takeaway

🎯 Key Insight: The lexicographic constraint creates a natural DP structure where each vowel choice restricts future options, leading to optimal substructure that we can solve bottom-up efficiently!

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25 Apple 18

The optimal solution uses bottom-up dynamic programming with O(n) time and O(1) space. We maintain an array where dp[i] represents strings ending with vowel i, updating each position by accumulating possibilities from vowels that can follow it alphabetically. The key insight is that once you choose a vowel, you're restricted to that vowel and all subsequent vowels in alphabetical order.

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up Dynamic Programming (Optimal)	O(n)	O(1)	Iteratively build solution using tabular DP approach
Dynamic Programming with Memoization	O(n × 5)	O(n × 5)	Cache recursive results to avoid repeated calculations

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP array with 1 for each vowel (base case: strings of length 1)
For each position from 2 to n, create new DP array
For vowel i, dp[i] = sum of all dp[j] where j >= i (can append vowel i after any vowel >= i)
Return sum of final DP array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize base case

dp = [1,1,1,1,1] for length 1

Update for length 2

Each position accumulates possibilities from right

Continue for length 3

Pattern continues, building on previous results

Sum final array

Total count = sum of all possibilities

Code -

solution.c — C

#include <stdio.h>

int countVowelStrings(int n) {
    // dp[i] = number of strings ending with vowel i
    int dp[5] = {1, 1, 1, 1, 1}; // base case: length 1
    
    for (int length = 2; length <= n; length++) {
        // Update dp array for current length
        for (int i = 3; i >= 0; i--) { // go backwards
            dp[i] += dp[i + 1];
        }
    }
    
    int result = 0;
    for (int i = 0; i < 5; i++) {
        result += dp[i];
    }
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", countVowelStrings(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop through n positions, with constant work per position

✓ Linear Growth

Space Complexity

O(1)

Only need to store counts for 5 vowels, can optimize to use single array

✓ Linear Space

78.3K Views

Medium-High Frequency

~12 min Avg. Time

2.8K 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

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler