5 Best Ways to Sort All Vowels at the Beginning Then the Consonants in Sorted Order in Python

Rate this post

πŸ’‘ Problem Formulation: The task at hand involves creating a Python program that rearranges the characters of a given string such that all vowels appear at the start of the string, followed by all consonants in alphabetically sorted order. For instance, given the input 'programming', the desired output would be 'oaigmnprmr'.

Method 1: Using Custom Sorting

Method 1 relies on defining a custom sorting function to prioritize vowels over consonants and then alphabetize. This method leverages the sorted function’s key parameter by passing a tuple that segments characters into vowels and non-vowels, which are then alphabetically sorted.

Here’s an example:

def custom_sort(char):
    vowels = 'aeiou'
    return (char not in vowels, char)
    
input_str = 'programming'
sorted_str = ''.join(sorted(input_str, key=custom_sort))
print(sorted_str)

Output:

oaigmnprmr

The custom_sort function returns a tuple for each character, with the first element indicating whether it’s a vowel (False) or a consonant (True), and the second element being the character itself. Characters are then sorted first by the boolean value (vowels come before consonants) and then alphabetically.

Method 2: Using Regular Expressions

Method 2 uses regular expressions to separate vowels and consonants and then concatenate the sorted results. The re module provides functions to match and separate character groups, leading to a concise solution.

Here’s an example:

import re

input_str = 'programming'
vowels = ''.join(sorted(re.findall('[aeiou]', input_str)))
consonants = ''.join(sorted(re.findall('[^aeiou]', input_str)))

sorted_str = vowels + consonants
print(sorted_str)

Output:

oaigmnprmr

This approach uses the re.findall() function twice, first to find all vowels and then to find all consonants. Both subsets of characters are sorted and concatenated to produce the sorted string with vowels preceding consonants.

Method 3: Using List Comprehensions

Method 3 capitalizes on list comprehensions to filter and sort vowels and consonants. This is an elegant one-liner approach creating readable and Pythonic code.

Here’s an example:

input_str = 'programming'
sorted_str = ''.join(sorted([c for c in input_str if c in 'aeiou']) +
                     sorted([c for c in input_str if c not in 'aeiou']))
print(sorted_str)

Output:

oaigmnprmr

In this snippet, two list comprehensions are used, one to gather all vowels from input_str and another for consonants. Both lists are sorted and concatenated to form the final ordered string.

Method 4: Using Lambdas

Method 4 makes use of a lambda function with the sorted function. The lambda defines the sorting key, simplifying the code needed to rank vowels before consonants and alphabetically sorting each group.

Here’s an example:

input_str = 'programming'
sorted_str = ''.join(sorted(input_str, key=lambda x: (x not in 'aeiou', x)))
print(sorted_str)

Output:

oaigmnprmr

The lambda function behaves similarly to the custom sort function in Method 1, returning a tuple where the first element indicates the character type and the second element is the character for sorting purposes.

Bonus One-Liner Method 5: Combining Functions

Method 5 offers a one-liner combining several built-in functions for a brief but effective solution. It showcases Python’s ability to chain iterable operations in a single line of code.

Here’s an example:

input_str = 'programming'
sorted_str = ''.join(sorted(input_str, key=lambda x: (x not in 'aeiou', ord(x))))
print(sorted_str)

Output:

oaigmnprmr

This one-liner modifies Method 4 by using Python’s ord() function to provide the ASCII value as the second sorting key, ensuring an alphabetical sort for the consonants after grouping the vowels first.

Summary/Discussion

  • Method 1: Custom Sorting. Highly readable and explicit. May be less efficient if the custom function is complex.
  • Method 2: Regular Expressions. Great for complex pattern matching. Can become unreadable with more complex patterns.
  • Method 3: List Comprehensions. Pythonic and concise. Readability can decrease with complexity.
  • Method 4: Lambdas. Neat and inline. Some might find lambdas obscure for readability.
  • Method 5: Combining Functions. Very concise. Potentially baffling for beginners.