Count Vowel Strings in Ranges

Count Vowel Strings in Ranges - Problem

You are given a 0-indexed array of strings words and a 2D array of integers queries.

Each query queries[i] = [li, ri] asks us to find the number of strings present at the indices ranging from li to ri (both inclusive) of words that start and end with a vowel.

Return an array ans of size queries.length, where ans[i] is the answer to the i^th query.

Note: The vowel letters are 'a', 'e', 'i', 'o', and 'u'.

Input & Output

Example 1 — Basic Case

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

› Output: [2,3]

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

Example 2 — Single Elements

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

› Output: [3,2]

💡 Note: All single vowel strings qualify. Query [0,2]: all 3 strings qualify. Query [0,1]: first 2 strings qualify.

Example 3 — No Valid Strings

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

› Output: [0]

💡 Note: "hello" starts with 'h', "world" starts with 'w', "code" ends with 'e' but starts with 'c'. None qualify.

Constraints

1 ≤ words.length ≤ 10⁵
1 ≤ words[i].length ≤ 40
words[i] consists only of lowercase English letters
sum(queries.length) ≤ 3 × 10⁵
0 ≤ queries[i][0] ≤ queries[i][1] < words.length

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use prefix sums for efficient range queries. After identifying words that start and end with vowels, build a cumulative count array. This allows answering any query [l,r] in O(1) time using the formula prefix[r+1] - prefix[l]. Best approach is prefix sum with Time: O(N + Q), Space: O(N).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(Q × N × M) Space: O(1)

For each query, iterate through the specified range and count words that start and end with vowels. Simple but inefficient for multiple queries.

Prefix Sum Optimization

⏱️ Time: O(N + Q) Space: O(N)

Build a prefix sum array where each position contains the count of valid words up to that index. This allows answering any range query in O(1) time.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

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

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

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse words array
    char** words = (char**)malloc(1000 * sizeof(char*));
    int wordsSize = 0;
    
    char* ptr = line1;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    ptr++; // Skip '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '"') {
            ptr++; // Skip opening quote
            char* start = ptr;
            while (*ptr && *ptr != '"') ptr++; // Find closing quote
            int len = ptr - start;
            words[wordsSize] = (char*)malloc((len + 1) * sizeof(char));
            strncpy(words[wordsSize], start, len);
            words[wordsSize][len] = '\0';
            wordsSize++;
            if (*ptr == '"') ptr++; // Skip closing quote
        }
        if (*ptr == ',' || *ptr == ' ') ptr++;
        else if (*ptr != ']') ptr++;
    }
    
    // Parse queries array
    int** queries = (int**)malloc(1000 * sizeof(int*));
    int queriesSize = 0;
    
    ptr = line2;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    ptr++; // Skip '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            queries[queriesSize] = (int*)malloc(2 * sizeof(int));
            ptr++; // Skip '['
            queries[queriesSize][0] = strtol(ptr, &ptr, 10);
            while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
            queries[queriesSize][1] = strtol(ptr, &ptr, 10);
            queriesSize++;
            while (*ptr && *ptr != ']') ptr++; // Find closing ']'
            if (*ptr == ']') ptr++;
        }
        if (*ptr == ',' || *ptr == ' ') ptr++;
        else if (*ptr != ']') ptr++;
    }
    
    int returnSize;
    int* result = vowelStrings(words, wordsSize, queries, queriesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]");
    
    // Cleanup
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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