string vowels — Problem Statement & Solution Guide

ArraysMedium

TimeO(n)

SpaceO(1)

Problem Description

You are provided with a string s consisting of lowercase English letters. Your task is to determine the total number of vowels present in the string. The vowels are defined strictly as 'a', 'e', 'i', 'o', and 'u'.

The function should iterate through the string and count every occurrence of these specific characters. Since the input is guaranteed to contain only lowercase letters, no case-insensitive handling is required.

Return an integer representing the count of vowels found in the string.

DSA Pattern Breakdown

"string vowels"

medium

WHY DOES IT MATTER?

Counting specific characters in a sequence is a foundational pattern used in parsing, validation, and analytics. Mastering this pattern equips engineers to handle a wide range of frequency‑based problems efficiently.

OPTIMIZATION CHALLENGE

The key insight is recognizing that the set of target characters (vowels) is fixed and tiny, allowing O(1) membership checks via a hash set or boolean array, which collapses any seemingly complex solution to a simple linear scan.

REAL-WORLD CONNECTION

Think of a log‑processing pipeline that needs to count error codes (e.g., '404') in a massive stream of web server logs. The same single‑pass, constant‑space technique applies, ensuring the system can scale without excessive memory consumption.

During an interview, write the lookup set first, then iterate with a for‑each loop; this order demonstrates clear thinking and avoids off‑by‑one errors, especially when handling edge cases like empty strings.

COMPLEXITY AT A GLANCE

⏱ Time:O(n)

💾 Space:O(1)

Core Theory — Why This Approach?

The problem of counting vowels in a string is a classic example of linear scanning, where each character must be examined exactly once to determine if it belongs to a predefined set. The naive approach might attempt to use nested loops or repeated string searches, which would inflate the time complexity to O(n^2) for large inputs. By recognizing that the vowel set is constant and small, we can employ a single-pass algorithm that checks membership in O(1) time per character, yielding an overall linear time solution.

In algorithmic theory, this falls under the category of "frequency counting" or "character classification" problems, which are often solved using hash tables or boolean lookup arrays. Since the alphabet size (26 lowercase letters) is fixed, a simple boolean array of size 26 or a hash set provides constant‑time membership checks. This eliminates the need for any auxiliary data structures that grow with input size, preserving O(1) auxiliary space.

The optimal paradigm leverages the principle of "single traversal with constant‑time work per element". By iterating once over the string and using a pre‑computed lookup (e.g., a set {'a','e','i','o','u'}), we achieve the theoretical lower bound for this problem: Θ(n) time and Θ(1) extra space, which is optimal for any algorithm that must inspect each character at least once.

Interview Questions on This Problem

Q1How would you modify the vowel‑counting algorithm to handle both uppercase and lowercase letters without increasing the time complexity?

Create a lookup set that includes both cases, e.g., {'a','e','i','o','u','A','E','I','O','U'}, and perform the same single pass. Alternatively, convert each character to lowercase (or uppercase) on the fly before the set check; both approaches remain O(n) time and O(1) space.

Q2If the input string could be extremely large (e.g., streaming data), how would you adapt your solution to work in a memory‑constrained environment?

Process the data as a stream, maintaining only a running count and checking each incoming character against the vowel set. Since no part of the string needs to be stored, the algorithm stays O(1) auxiliary space and O(n) time over the total number of characters received.

Q3Can you extend the algorithm to return the indices of all vowels in the string while still keeping the time complexity linear?

Yes. While scanning, whenever a vowel is encountered, append its index to a result list. This adds O(k) extra space where k is the number of vowels, but the time remains O(n) because each character is still processed once.

Examples

Example 1

Input

s = "aeiou"

Output

Explanation: The string contains 'a', 'e', 'i', 'o', 'u'. All 5 characters are vowels. Count = 5.

Example 2

Input

s = "rhythm"

Output

Explanation: The string contains 'r', 'h', 'y', 't', 'h', 'm'. None of these are vowels (y is not considered a vowel here). Count = 0.

Example 3

Input

s = "algorithm"

Output

Explanation: Characters: 'a' (vowel), 'l', 'g', 'o' (vowel), 'r', 'i' (vowel), 't', 'h', 'm'. Total vowels = 3.

Example 4

Input

s = "programming"

Output

Explanation: Characters: 'p', 'r', 'o' (vowel), 'g', 'r', 'a' (vowel), 'm', 'm', 'i' (vowel), 'n', 'g'. Wait, 'i' is a vowel. Let's re-check: p-r-o-g-r-a-m-m-i-n-g. Vowels: o, a, i. Count = 3. Correction: The example output should be 3. Let's pick a different string to avoid confusion or correct the output. Let's use "xyz". Input: "xyz", Output: 0. Let's stick to the previous valid ones. Let's add one more: s = "beautiful". b-e-a-u-t-i-f-u-l. Vowels: e, a, u, i, u. Count = 5.

Constraints

1 <= s.length <= 10^5
s consists of lowercase English letters only

Optimal Approach & Strategy

Iterate once over the string and check each character against a constant‑time vowel lookup set, achieving O(n) time and O(1) auxiliary space.

Brute Force Approach

Use nested loops or repeatedly call string search functions for each vowel, leading to O(n × v) time where v is the number of vowels.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(n)

function countVowels(str) {
   if (typeof str !== 'string') {
       throw new Error('Input must be a string.');
   }
   let count = 0;
   for (let i = 0; i < str.length; i++) {
       if ('aeiouAEIOU'.includes(str[i].toLowerCase())) {
           count++;
       }
   }
   return count;
}


       #include <iostream>
       #include <string>
       int countVowels(std::string str) {
           int count = 0;
           for (char c : str) {
               if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
                   count++;
               }
           }
           return count;
       }

public int countVowels(String s) {
    // Convert the string to lowercase
    s = s.toLowerCase();
    // Initialize a counter for vowels
    int count = 0;
    // Iterate over each character in the string
    for (char c : s.toCharArray()) {
        // Check if the character is a vowel
        if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
            // Increment the count if the character is a vowel
            count++;
        }
    }
    // Return the count of vowels
    return count;
}

def count_vowels(s):
    # Convert the string to lowercase
    s = s.lower()
    # Initialize a counter for vowels
    count = 0
    # Iterate over each character in the string
    for char in s:
        # Check if the character is a vowel
        if char in 'aeiou':
            # Increment the count if the character is a vowel
            count += 1
    # Return the count of vowels
    return count

function countVowels(str) {
   if (typeof str !== 'string') {
       throw new Error('Input must be a string.');
   }
   let count = 0;
   for (let i = 0; i < str.length; i++) {
       if ('aeiouAEIOU'.includes(str[i].toLowerCase())) {
           count++;
       }
   }
   return count;
}

Asked in Top Tech Interviews

RazorpayAtlassian

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

string vowels Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Input

Output

Constraints

More Arrays

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

string vowels — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor