Count Vowels Permutation - Practice Coding Problems

Count Vowels Permutation - Problem

Dynamic Programming Hard

Count Vowels Permutation

Imagine you're creating a special language where vowels follow strict pronunciation rules! Given an integer n, you need to count how many valid strings of length n can be formed using only lowercase vowels ('a', 'e', 'i', 'o', 'u') following these pronunciation transition rules:

• Each vowel 'a' may only be followed by an 'e'
• Each vowel 'e' may only be followed by an 'a' or an 'i'
• Each vowel 'i' may not be followed by another 'i' (can be followed by 'a', 'e', 'o', 'u')
• Each vowel 'o' may only be followed by an 'i' or a 'u'
• Each vowel 'u' may only be followed by an 'a'

Since the answer can be extremely large, return it modulo 10⁹ + 7.

Example: For n = 1, we can form 5 strings: "a", "e", "i", "o", "u". For n = 2, we can form 10 valid strings like "ae", "ea", "ei", "ia", "ie", "io", "oi", "ou", "ua", "ue".

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 5

💡 Note: For length 1, each vowel can form a valid string by itself: "a", "e", "i", "o", "u". Total = 5 strings.

example_2.py — Length 2

$ Input: n = 2

› Output: 10

💡 Note: Valid 2-character strings following the rules: "ae" (a→e), "ea" (e→a), "ei" (e→i), "ia" (i→a), "ie" (i→e), "io" (i→o), "iu" (i→u), "oi" (o→i), "ou" (o→u), "ua" (u→a). Total = 10 strings.

example_3.py — Larger Input

$ Input: n = 5

› Output: 68

💡 Note: For length 5, applying the DP transitions through all levels gives us 68 valid strings that follow all the vowel transition rules.

Constraints

1 ≤ n ≤ 2 × 10⁴
Return result modulo 10⁹ + 7
Each character must be a lowercase vowel ('a', 'e', 'i', 'o', 'u')

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Create a directed graph where vowels are nodes and edges represent allowed transitions

Count Paths

Use DP to count all paths of length n through this transition graph

Apply Rules

At each step, distribute current counts to next valid vowels based on transition rules

Sum Results

Final answer is sum of all valid strings ending with any vowel

Key Takeaway

🎯 Key Insight: Transform the string generation problem into a state transition counting problem. By tracking counts instead of generating actual strings, we achieve optimal O(n) time complexity.

Asked in

f Facebook 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses Dynamic Programming to track counts of valid strings ending with each vowel at each length. Instead of generating all possible strings (O(5ⁿ)), we maintain 5 counters and apply transition rules to build up the answer in O(n) time and O(1) space. The key insight is that we only need to know how many strings end with each vowel, not the actual strings themselves.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Brute Force	O(5^n)	O(n)	Generate all possible strings recursively and count valid ones
Dynamic Programming (Optimal)	O(n)	O(1)	Track counts of strings ending with each vowel using DP transitions

Recursive Brute Force — Algorithm Steps

Start with an empty string and position 0
For each position, try placing each vowel ('a', 'e', 'i', 'o', 'u')
Check if the current vowel can follow the previous vowel based on rules
If valid, recursively build the rest of the string
When we reach length n, increment the count
Return the total count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at root

Begin with empty string, try all 5 vowels

Apply rules

For each vowel, only explore valid next vowels

Count leaves

Each complete path of length n contributes 1 to the answer

Code -

solution.c — C

#include <stdio.h>

const int MOD = 1000000007;

int dfs(int pos, char prevVowel, int n) {
    if (pos == n) {
        return 1;
    }
    
    long long count = 0;
    if (pos == 0) {
        char vowels[] = {'a', 'e', 'i', 'o', 'u'};
        for (int i = 0; i < 5; i++) {
            count = (count + dfs(pos + 1, vowels[i], n)) % MOD;
        }
    } else {
        switch(prevVowel) {
            case 'a':
                count = (count + dfs(pos + 1, 'e', n)) % MOD;
                break;
            case 'e':
                count = (count + dfs(pos + 1, 'a', n)) % MOD;
                count = (count + dfs(pos + 1, 'i', n)) % MOD;
                break;
            case 'i':
                count = (count + dfs(pos + 1, 'a', n)) % MOD;
                count = (count + dfs(pos + 1, 'e', n)) % MOD;
                count = (count + dfs(pos + 1, 'o', n)) % MOD;
                count = (count + dfs(pos + 1, 'u', n)) % MOD;
                break;
            case 'o':
                count = (count + dfs(pos + 1, 'i', n)) % MOD;
                count = (count + dfs(pos + 1, 'u', n)) % MOD;
                break;
            case 'u':
                count = (count + dfs(pos + 1, 'a', n)) % MOD;
                break;
        }
    }
    
    return (int)count;
}

int countVowelPermutation(int n) {
    return dfs(0, ' ', n);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(5^n)

At each position we try up to 5 vowels, leading to exponential growth

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth is n for the string length

⚡ Linearithmic Space

89.4K Views

Medium-High Frequency

~25 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

Recursive Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler