Sort Vowels in a String - Practice Coding Problems

Sort Vowels in a String - Problem

String Sorting Medium

Given a string s, you need to create a new string where all consonants stay in their original positions but all vowels are sorted by their ASCII values.

Think of it like organizing a library: the shelves (consonant positions) stay fixed, but you rearrange the books (vowels) in alphabetical order within those shelves.

The Rules:

🔒 Consonants must remain in their exact original positions
📝 Vowels (a, e, i, o, u - both lowercase and uppercase) should be sorted by ASCII value
🎯 ASCII sorting means: A < E < I < O < U < a < e < i < o < u

Example: "lEetcOde" → "lEOtcede"
Vowels found: [E, e, O, e] → Sorted: [E, O, e, e]
Place them back: lE*tcOde → lE*tcede

Input & Output

example_1.py — Basic Case

$ Input: s = "lEetcOde"

› Output: "lEOtcede"

💡 Note: The vowels are [E, e, O, e]. After sorting by ASCII: [E, O, e, e]. Placing them back: l(E)*(O)tc(e)d(e) = "lEOtcede". Consonants l, t, c, d stay in their original positions.

example_2.py — Mixed Case

$ Input: s = "lYmpH"

› Output: "lYmpH"

💡 Note: No vowels found in the string (Y is not considered a vowel in this problem). The string remains unchanged since only consonants are present.

example_3.py — All Vowels

$ Input: s = "AeIoU"

› Output: "AeIoU"

💡 Note: All characters are vowels: [A, e, I, o, U]. After ASCII sorting: [A, I, U, e, o]. Result: "AIUeo". Wait, that's wrong... Let me recalculate: ASCII values: A(65), I(73), U(85), e(101), o(111). So sorted: A, I, U, e, o → "AIUeo"

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of letters (both uppercase and lowercase)
Vowels are: a, e, i, o, u, A, E, I, O, U
All other letters are considered consonants

Visualization

Tap to expand

Understanding the Visualization

Identify Positions

Mark vowel positions (red) and consonant positions (blue) in the original string

Extract & Sort

Remove all vowels and sort them by ASCII values: A-Z comes before a-z

Replace in Order

Put sorted vowels back into vowel positions sequentially

Final Result

Consonants unchanged, vowels properly sorted by ASCII values

Key Takeaway

🎯 Key Insight: The two-pass approach is optimal - first collect and sort all vowels, then place them back sequentially in vowel positions while preserving consonant positions.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 29 f Meta 22

The optimal approach uses a two-pass algorithm: first extract all vowels and sort them by ASCII value, then replace vowels in the original string with sorted ones while keeping consonants in place. Time complexity: O(n + V log V) where V is the number of vowels, Space: O(V).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass: Extract, Sort, Replace	O(n + V log V)	O(V)	Extract all vowels, sort them, then place them back in vowel positions
Brute Force (Selection Sort on Vowels)	O(n²)	O(1)	For each vowel position, find the smallest remaining vowel and place it there

Two-Pass: Extract, Sort, Replace — Algorithm Steps

First pass: Iterate through string and collect all vowels in a list
Sort the collected vowels by their ASCII values
Second pass: Iterate through string again with a vowel pointer
For each vowel position, replace with next vowel from sorted list
Leave all consonant positions unchanged

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Vowels

First pass: collect all vowels from the string

Sort Vowels

Sort the extracted vowels by ASCII value

Replace Vowels

Second pass: put sorted vowels back in vowel positions

Final Result

Consonants unchanged, vowels sorted

Code -

solution.c — C

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

bool isVowel(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
           c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
}

int compareChar(const void* a, const void* b) {
    return (*(char*)a - *(char*)b);
}

char* sortVowels(char* s) {
    int len = strlen(s);
    char vowels[len];
    int vowelCount = 0;
    
    // First pass: extract all vowels
    for (int i = 0; i < len; i++) {
        if (isVowel(s[i])) {
            vowels[vowelCount++] = s[i];
        }
    }
    
    // Sort vowels by ASCII value
    qsort(vowels, vowelCount, sizeof(char), compareChar);
    
    // Second pass: replace vowels in original string
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int vowelIndex = 0;
    
    for (int i = 0; i < len; i++) {
        if (isVowel(s[i])) {
            result[i] = vowels[vowelIndex++];
        } else {
            result[i] = s[i];
        }
    }
    result[len] = '\0';
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    char* result = sortVowels(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + V log V)

O(n) to scan string twice, O(V log V) to sort vowels where V ≤ n, so overall O(n + V log V)

⚡ Linearithmic

Space Complexity

O(V)

Extra space needed to store extracted vowels, where V is the number of vowels in the string

✓ Linear Space

42.3K Views

Medium Frequency

~15 min Avg. Time

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

Two-Pass: Extract, Sort, Replace — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler