Swift 字符串的反向元音

问题是要反转字符串的元音，就像输入“hello”，输出应该是“holle”

我搜索了swift中没有这样的问题，所以我想将此作为讨论发布

我写的代码如下所示，结果是需要12毫秒来逆转这个“你好”，有人有更好的解决方案使用swift功能吗

class Solution {
    func reverseVowels(s: String) -> String {
        if s == "" { return "" }
        let vowels = ["a","e","i","o","u","A","E","I","O","U"]
        var sVowels = [Character]()
        var reversedStr = ""
        for vChar in s.characters {
            if vowels.contains(String(vChar)) {
                sVowels.append(vChar)
            }
        }
        for char in s.characters {
            if !vowels.contains(String(char)) {
                reversedStr = reversedStr + String(char)
            } else if vowels.contains(String(char)) {
                reversedStr = reversedStr + String(sVowels.removeLast())
            }
        }

       return reversedStr
    }
}

---

你的问题更多的是一个算法问题，而不是一个快速的问题。我对斯威夫特一无所知

这是我用Java编写的算法解决方案。以下是您可以在代码中使用的要点：

使用哈希表存储元音。然后可以在O（1）时间内执行查找。我认为在您的Swift代码中，您使用的是一个数组，这可能需要O（n）个时间进行搜索

将输入字符串转换为数组，以便可以直接在数组中操作（交换）字符，而不是重建新字符串。在我的代码中，我只在末尾创建一个新字符串

import java.util.Set；
导入java.util.HashSet；
导入java.util.array；
公共类反向世界{
公共静态字符串反转窗口（字符串s）{
//为元音创建哈希表。
设定元音=
新哈希集(
asList（'a'，'e'，'i'，'o'，'u'，'a'，'e'，'i'，'o'，'u'）；
//将输入字符串转换为数组，以便写入。
char[]result=s.toCharArray（）；
int i=0；
int j=结果长度-1；
而（i

输出：

% java ReverseVowels
holle
qwatopuebt

---

快速翻译：

func reverseVowels(s: String) -> String {
    // Create a set for vowels.
    let vowels: Set<Character> = ["a","e","i","o","u","A","E","I","O","U"]

    // Convert input string to array so that we can write into it.
    var result = Array(s.characters)

    var i = 0
    var j = result.count - 1
    while i < j {
        if !vowels.contains(result[i]) {
            i += 1
        }
        else if !vowels.contains(result[j]) {
            j -= 1
        }
        else {
            // Both are vowels.
            let temp = result[i]
            result[i] = result[j]
            result[j] = temp
            i += 1
            j -= 1
        }
    }
    return String(result)
}

func reverseVowels（s:String）->String{
//为元音创建一个集合。
让元音：Set=[“a”，“e”，“i”，“o”，“u”，“a”，“e”，“i”，“o”，“u”]
//将输入字符串转换为数组，以便写入。
变量结果=数组（s个字符）
变量i=0
var j=result.count-1
而我{
if！元音.contains（结果[i]）{
i+=1
}
else if！元音.contains（结果[j]）{
j-=1
}
否则{
//两者都是元音。
设温度=结果[i]
结果[i]=结果[j]
结果[j]=温度
i+=1
j-=1
}
}
返回字符串（结果）
}

试试这个：

func reverseVowels(s: String) -> String {
    if s == "" { return "" }
    let vowels: Set<Character> = ["a","e","i","o","u","A","E","I","O","U"]
    var indices = [Int]()
    var chars = Array(s.characters)
    for (index, vChar) in chars.enumerate() {
        if vowels.contains(vChar) {
            indices.append(index)
        }
    }
    let count = indices.count
    for i in 0 ..< count/2 {
        swap(&chars[indices[i]], &chars[indices[count - i - 1]])
    }

    return String(chars)
}

func reverseVowels（s:String）->String{
如果s==“{return”“}”
让元音：Set=[“a”，“e”，“i”，“o”，“u”，“a”，“e”，“i”，“o”，“u”]
var指数=[Int]（）
var chars=数组（s个字符）
for（索引，vChar）在chars.enumerate（）中{
if元音.contains（vChar）{
索引。追加（索引）
}
}
让count=index.count
对于0中的i..<计数/2{
交换（&chars[index[i]]，&chars[index[count-i-1]]））
}
返回字符串（字符）
}

算法：

将

元音

设置为

集

，以减少转换并加快

包含的

（感谢@AlexMomchliov的

集

想法）

将字符串转换为

[字符]

找出元音的位置

交换元音

从

[字符]

要添加到解决方案，请执行以下操作：

与其他流行语言（即C#和Java）不同，Swift不要求所有函数都在一个类中<代码>解决方案是一个不需要存在的任意类。在Swift中，您可以将函数编写为自己的独立实体

然而，还有一种更好的快速方法。您可以将函数放入

String

的扩展中，这将产生一些非常好的语法：

extension String {

    static let vowels: Set<Character> = ["a","e","i","o","u","A","E","I","O","U"]

    func reverseVowels() -> String {
        if self == "" { return "" }

        var chars = Array(self.characters)

        let indices = chars.enumerate().filter{ String.vowels.contains($0.1) }.map{ $0.0 }

        let count = indices.count
        for i in 0 ..< count/2 {
            swap(&chars[indices[i]], &chars[indices[count - i - 1]])
        }

        return String(chars)
    }
}

"A test string".reverseVowels() //you can call your method directly on a string

扩展字符串{
静态let元音：Set=[“a”、“e”、“i”、“o”、“u”、“a”、“e”、“i”、“o”、“u”]
func reverseVowels（）->字符串{
如果self==“返回”}
var chars=数组（self.characters）
让index=chars.enumerate（）.filter{String.元音.contains（$0.1）}.map{$0.0}
让count=index.count
对于0中的i..<计数/2{
交换（&chars[index[i]]，&chars[index[count-i-1]]））
}
返回字符串（字符）
}
}
“测试字符串”。reverseVowels（）//您可以直接对字符串调用您的方法

我对答案做了其他改进：

现在可以将

元音

移动为

字符串

类的静态成员，这样就不会在每次调用

reverseVowels（）

时重新生成元音（尽管编译器可能会对此进行优化）

元音

现在是一个

集合

，而不是一个

数组

，以便使用更快版本的

contains（）

。通过我的测试，这使得1.4x左右的函数更快

切换到以功能性、不变的方式生成

索引

数组

另一种方式：

1拾取所有元音，并将其反转

2将原始字符串中的所有元音映射为反向元音

func reverseVowels(s: String) -> String {
    let vowelSet: Set<Character> = ["a","e","i","o","u","A","E","I","O","U"]
    var reversedVowelIterator = s.characters.filter{vowelSet.contains($0)}.lazy.reverse().generate()
    return String(s.characters.map{vowelSet.contains($0) ? reversedVowelIterator.next()! : $0})
}

print(reverseVowels("hello")) //->holle
print(reverseVowels("Reverse Vowels of a String")) //->Rivarso Vewols ef e Streng

func reverseVowels（s:String）->String{
让元音Set:Set=[“a”，“e”，“i”，“o”，“u”，“a”，“e”，“i”，“o”，“u”]
var reversedvoueliterator=s.characters.filter{vouelset.contains（$0）}.lazy.reverse（）.generate（）
返回字符串（s.characters.map{vouelset.contains（$0）？ReversedVoueLiterator.next（）！：$0}）
}
打印（reverseVowels（“hello”））/->holle
print（reverseVowels（“字符串的反向元音”）/->Rivarso Vewols ef e Streng

回答得很好！我在回答中做了一些改进，你可能想看看。这正是我应该做的。尝试添加一个快速的版本