Count Vowel Strings in Ranges - Practice Coding Problems

Count Vowel Strings in Ranges - Problem

Imagine you're working with a text analysis system that needs to quickly answer queries about specific word patterns. You have an array of words and need to efficiently handle multiple range queries.

Given a 0-indexed array of strings words and a 2D array of integers queries, your task is to count how many words in each specified range start and end with a vowel.

Each query queries[i] = [li, ri] asks: "How many strings at indices from li to ri (both inclusive) start and end with a vowel?"

Return an array ans where ans[i] is the answer to the i-th query.

Note: Vowels are 'a', 'e', 'i', 'o', and 'u' (case-sensitive).

Input & Output

example_1.py — Basic Case

$ Input: words = ["aba","bcb","ece","aa","e"], queries = [[0,2],[1,4],[1,1]]

› Output: [2,3,0]

💡 Note: Query [0,2]: "aba"(✓), "bcb"(✗), "ece"(✓) → count = 2. Query [1,4]: "bcb"(✗), "ece"(✓), "aa"(✓), "e"(✓) → count = 3. Query [1,1]: "bcb"(✗) → count = 0.

example_2.py — Single Character

$ Input: words = ["a","e","i"], queries = [[0,2],[0,1]]

› Output: [3,2]

💡 Note: All single vowel characters start and end with vowels. Query [0,2]: all 3 words qualify. Query [0,1]: first 2 words qualify.

example_3.py — No Matches

$ Input: words = ["hello","world","coding"], queries = [[0,2],[1,2]]

› Output: [0,0]

💡 Note: None of the words start and end with vowels: "hello"(consonant-vowel), "world"(consonant-consonant), "coding"(consonant-consonant).

Constraints

1 ≤ words.length ≤ 10⁵
1 ≤ words[i].length ≤ 40
words[i] consists only of lowercase English letters
1 ≤ queries.length ≤ 3 × 10⁵
queries[i] = [l_i, r_i]
0 ≤ l_i ≤ r_i < words.length

Visualization

Tap to expand

Understanding the Visualization

Scan and Mark

Go through each word, check if it starts and ends with vowels

Build Prefix

Create cumulative sum: prefix[i] = total count from start to position i-1

Range Query

For range [l,r]: answer = prefix[r+1] - prefix[l]

Instant Result

Each query answered in O(1) time using simple arithmetic

Key Takeaway

🎯 Key Insight: Prefix sums transform O(N) range queries into O(1) arithmetic operations, making this approach optimal for multiple queries.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses prefix sums to preprocess the data once in O(N) time, then answer each of the Q queries in O(1) time. Key insight: range sum query count(l,r) = prefix[r+1] - prefix[l]. Total complexity: O(N + Q) time, O(N) space.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum Optimization (Optimal)	O(N + Q)	O(N)	Precompute prefix sums for O(1) range queries
Brute Force (Nested Loops)	O(Q * N * M)	O(1)	For each query, iterate through the range and count vowel strings

Prefix Sum Optimization (Optimal) — Algorithm Steps

Create helper function to check vowel condition
Build prefix sum array by scanning words once
Each prefix[i] = count of valid words from 0 to i-1
For query [l,r]: answer = prefix[r+1] - prefix[l]
Return all query results

Visualization

Tap to expand

Step-by-Step Walkthrough

Preprocess

Build cumulative count array

Store Prefix

prefix[i] = total valid words from 0 to i-1

Range Query

count(l,r) = prefix[r+1] - prefix[l]

O(1) Answer

Instant result using subtraction

Code -

solution.c — C

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

bool startsEndsVowel(char* word) {
    int len = strlen(word);
    if (len == 0) return false;
    return isVowel(word[0]) && isVowel(word[len-1]);
}

int* vowelStrings(char** words, int wordsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    
    // Build prefix sum array
    int* prefix = (int*)calloc(wordsSize + 1, sizeof(int));
    for (int i = 0; i < wordsSize; i++) {
        prefix[i + 1] = prefix[i] + (startsEndsVowel(words[i]) ? 1 : 0);
    }
    
    // Answer queries
    int* result = (int*)malloc(queriesSize * sizeof(int));
    for (int i = 0; i < queriesSize; i++) {
        int left = queries[i][0];
        int right = queries[i][1];
        result[i] = prefix[right + 1] - prefix[left];
    }
    
    free(prefix);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(N + Q)

N for preprocessing, Q for answering all queries (each in O(1))

✓ Linear Growth

Space Complexity

O(N)

Additional array to store prefix sums

✓ Linear Space

67.3K Views

High Frequency

~18 min Avg. Time

1.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

Prefix Sum Optimization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler