2785. Sort Vowels in a String

Description

Given a 0-indexed string s, permute s to get a new string t such that:

• All consonants remain in their original places. More formally, if there is an index i with 0 <= i < s.length such that s[i] is a consonant, then t[i] = s[i].
• The vowels must be sorted in the nondecreasing order of their ASCII values. More formally, for pairs of indices i, j with 0 <= i < j < s.length such that s[i] and s[j] are vowels, then t[i] must not have a higher ASCII value than t[j].

Return the resulting string.

The vowels are 'a', 'e', 'i', 'o', and 'u', and they can appear in lowercase or uppercase. Consonants comprise all letters that are not vowels.

Example 1:

Input: s = "lEetcOde"
Output: "lEOtcede"
Explanation: 'E', 'O', and 'e' are the vowels in s; 'l', 't', 'c', and 'd' are all consonants. The vowels are sorted according to their ASCII values, and the consonants remain in the same places.


Example 2:

Input: s = "lYmpH"
Output: "lYmpH"
Explanation: There are no vowels in s (all characters in s are consonants), so we return "lYmpH".


Constraints:

• 1 <= s.length <= 105
• s consists only of letters of the English alphabet in uppercase and lowercase.

Solutions

• class Solution {
public String sortVowels(String s) {
List<Character> vs = new ArrayList<>();
char[] cs = s.toCharArray();
for (char c : cs) {
char d = Character.toLowerCase(c);
if (d == 'a' || d == 'e' || d == 'i' || d == 'o' || d == 'u') {
}
}
Collections.sort(vs);
for (int i = 0, j = 0; i < cs.length; ++i) {
char d = Character.toLowerCase(cs[i]);
if (d == 'a' || d == 'e' || d == 'i' || d == 'o' || d == 'u') {
cs[i] = vs.get(j++);
}
}
return String.valueOf(cs);
}
}

• class Solution {
public:
string sortVowels(string s) {
string vs;
for (auto c : s) {
char d = tolower(c);
if (d == 'a' || d == 'e' || d == 'i' || d == 'o' || d == 'u') {
vs.push_back(c);
}
}
sort(vs.begin(), vs.end());
for (int i = 0, j = 0; i < s.size(); ++i) {
char d = tolower(s[i]);
if (d == 'a' || d == 'e' || d == 'i' || d == 'o' || d == 'u') {
s[i] = vs[j++];
}
}
return s;
}
};

• class Solution:
def sortVowels(self, s: str) -> str:
vs = [c for c in s if c.lower() in "aeiou"]
vs.sort()
cs = list(s)
j = 0
for i, c in enumerate(cs):
if c.lower() in "aeiou":
cs[i] = vs[j]
j += 1
return "".join(cs)


• func sortVowels(s string) string {
cs := []byte(s)
vs := []byte{}
for _, c := range cs {
d := c | 32
if d == 'a' || d == 'e' || d == 'i' || d == 'o' || d == 'u' {
vs = append(vs, c)
}
}
sort.Slice(vs, func(i, j int) bool { return vs[i] < vs[j] })
j := 0
for i, c := range cs {
d := c | 32
if d == 'a' || d == 'e' || d == 'i' || d == 'o' || d == 'u' {
cs[i] = vs[j]
j++
}
}
return string(cs)
}

• function sortVowels(s: string): string {
const vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'];
const vs = s
.split('')
.filter(c => vowels.includes(c))
.sort();
const ans: string[] = [];
let j = 0;
for (const c of s) {
ans.push(vowels.includes(c) ? vs[j++] : c);
}
return ans.join('');
}


• public class Solution {
public string SortVowels(string s) {
List<char> vs = new List<char>();
char[] cs = s.ToCharArray();
foreach (char c in cs) {
if (IsVowel(c)) {
}
}
vs.Sort();
for (int i = 0, j = 0; i < cs.Length; ++i) {
if (IsVowel(cs[i])) {
cs[i] = vs[j++];
}
}
return new string(cs);
}

public bool IsVowel(char c) {
c = char.ToLower(c);
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
}