[Swift]LeetCode824. 山羊拉丁文 | Goat Latin

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10588657.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

A sentence S is given, composed of words separated by spaces. Each word consists of lowercase and uppercase letters only.

We would like to convert the sentence to "Goat Latin" (a made-up language similar to Pig Latin.)

The rules of Goat Latin are as follows:

• If a word begins with a vowel (a, e, i, o, or u), append "ma" to the end of the word.
  For example, the word 'apple' becomes 'applema'.
   
• If a word begins with a consonant (i.e. not a vowel), remove the first letter and append it to the end, then add "ma".
  For example, the word "goat" becomes "oatgma".
   
• Add one letter 'a' to the end of each word per its word index in the sentence, starting with 1.
  For example, the first word gets "a"added to the end, the second word gets "aa" added to the end and so on.

Return the final sentence representing the conversion from S to Goat Latin. 

Example 1:

Input: "I speak Goat Latin"
Output: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"

Example 2:

Input: "The quick brown fox jumped over the lazy dog"
Output: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"

Notes:

• S contains only uppercase, lowercase and spaces. Exactly one space between each word.
• 1 <= S.length <= 150.

---

给定一个由空格分割单词的句子 S。每个单词只包含大写或小写字母。

我们要将句子转换为 “Goat Latin”（一种类似于 猪拉丁文 - Pig Latin 的虚构语言）。

山羊拉丁文的规则如下：

• 如果单词以元音开头（a, e, i, o, u），在单词后添加"ma"。
  例如，单词"apple"变为"applema"。

• 如果单词以辅音字母开头（即非元音字母），移除第一个字符并将它放到末尾，之后再添加"ma"。
  例如，单词"goat"变为"oatgma"。
• 根据单词在句子中的索引，在单词最后添加与索引相同数量的字母'a'，索引从1开始。

例如，在第一个单词后添加"a"，在第二个单词后添加"aa"，以此类推。

返回将 S 转换为山羊拉丁文后的句子。

示例 1:

输入: "I speak Goat Latin"
输出: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"

示例 2:

输入: "The quick brown fox jumped over the lazy dog"
输出: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"

说明:

• S 中仅包含大小写字母和空格。单词间有且仅有一个空格。
• 1 <= S.length <= 150。

---

Runtime: 12 ms

Memory Usage: 20.5 MB

import XCTest
class Solution {
    func toGoatLatin(_ S: String) -> String {
        let vowels = ["a", "e", "i", "o", "u"]
        var result = ""
        S.split(separator: " ").enumerated().forEach { i, word in
        guard let firstChar = word.first.map(String.init) else { return }
        if !vowels.contains(firstChar.lowercased()) {
            result.append(word.dropFirst() + firstChar + "ma")
        } else {
            result.append(word + "ma")
        }
        result += String(repeating: "a", count: i + 1) + " "
    }
    return String(result.dropLast())
    }
}

---

12ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
        var result: String = ""
        var toAppend = ""
        let ma = "ma"
        var a = ""
        
        enum Status {
            case blank
            case character
        }
        var status = Status.blank
        
        for char in S {
            switch status {
            case .blank:
                switch char {
                case " ":
                    break
                case "a", "e", "i", "o", "u", "A", "E", "I", "O", "U":
                    result.append(char)
                    toAppend = ""
                    a += "a"
                    status = .character
                default:
                    toAppend = String(char)
                    a += "a"
                    status = .character
                }
            case .character:
                switch char {
                case " ":
                    result.append(toAppend)
                    result.append(ma)
                    result.append(a)
                    result.append(char)
                    status = .blank
                default:
                    result.append(char)
                }
            }
        }
        result.append(toAppend)
        result.append(ma)
        result.append(a)
        return result
    }
}

---

16ms

class Solution {
    var vowels : Set<Character> = ["a","e","i","o","u","A","E","I","O","U"]
    func toGoatLatin(_ S: String) -> String {
        var result = ""
        let subStrs = S.split(separator: " ")
        var  suffix  = "a"
        for item in subStrs {
            var temp = item
            if !vowels.contains(temp.first!) {
                let char = temp.removeFirst()
                temp.append(char)
            }
            result += (temp + "ma" + suffix + " ")
            suffix += "a"
        }
        result.removeLast()
        return result
    }
}

---

20ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
  let setVowels = CharacterSet(charactersIn: "aeiou")
        var arrayWords = [String]()
        
        for (index,word) in S.components(separatedBy: " ").enumerated(){
            
            var newWord = word
            if String(word.first!).lowercased().rangeOfCharacter(from: setVowels) != nil{
                newWord.append("ma")
            }
            else{
                newWord.append(newWord.removeFirst())
                newWord.append("ma")
            }
            
            for _ in 0...index{
                newWord.append("a")
            }
            arrayWords.append(newWord)
        }
        
        return arrayWords.joined(separator: " ")
    }
}

---

24ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
        let y = ["a","A","e","E","i","I","o","O","u","U"]
        let a = S.components(separatedBy: " ")
        var b = "a"
        var c:[String] = []
        var d:[String] = []
        for var i in a {
            if y.contains((i[i.startIndex]).description){
                i+="ma"
            }else{
                i.append(i[i.startIndex])
                i.remove(at: i.startIndex)
                i+="ma"
            }
            c.append(i)
        }
        for var i in c {
            i.append(b)
            d.append(i)
            b+="a"
        }
        
        return d.joined(separator: " ")
    }
}

---

28ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
         var temp = S.split(separator: " ")
        var goatLatin = ""
         for (i,v) in temp.enumerated(){
             var result = ""
            if  ["a","e", "i", "o", "u","A","E","I","O","U"].contains(v.first) {
                result =  String(v) + "ma"
            }
            else {
                result = String(v) + String(v.first!)
                result.remove(at:result.startIndex)
                result = result + "ma"
            }
             for index in  0 ..< i+1 {
            result = result + "a"
             }
              goatLatin = goatLatin + result + " "
        }
        return goatLatin.trimmingCharacters(in: .whitespaces)
    }
}

---

28ms

class Solution {
func toGoatLatin(_ S: String) -> String {
    let chaArr = "aeiouAEIOU"
    var tmpArr = [String]()
    let strArr = S.components(separatedBy: " ")
    for (index,item) in strArr.enumerated() {
        var str = item
        if chaArr.contains(item.first!) && item.count != 1 {
            str = str + "ma"
        } else {
            str.append(item.first!)
            str.removeFirst()
            str.append("ma")
        }
        var tmpIndex = index + 1
        while(tmpIndex != 0) {
            str.append("a")
            tmpIndex -= 1
        }
        tmpArr.append(str)
    }
    return tmpArr.joined(separator: " ")
  }
}

---

32ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
        let vowelSet = Set<Character>(["A", "E", "I", "O", "U", "a", "e", "i", "o", "u"])
        var charsArr = S.split(separator: " ").map { Array($0) }
        let ma: [Character] = ["m", "a"]
        let a: Character = "a"

        for (i, var chars) in charsArr.enumerated() {
            if !vowelSet.contains(chars[0]) {
                let firstChar = chars.remove(at: 0)
                chars.append(firstChar)
            }
            chars.append(contentsOf: ma)
            chars.append(contentsOf: Array(repeating: a, count: i + 1))

            charsArr[i] = chars
        }

        return charsArr.map { String($0) }.joined(separator: " ")
    }
}

---

44ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
        var newString = ""
        var posfix = ""
        let maString = "ma"
        let vowels = ["a", "e", "i", "o", "u", "A", "E", "I", "O", "U"]
        let words = S.components(separatedBy: CharacterSet.whitespaces)
        
        for i in 0..<words.count {
            posfix += "a"
            let word = words[i]
            let prefix = String(word.first!)
            if vowels.contains(prefix) {
                newString += word + maString + posfix
            } else {
                newString += word[word.index(after: word.startIndex)..<word.endIndex] + prefix + maString + posfix
            }
            
            if i < words.count - 1 {
                newString += " "
            }
        }
        
        return newString
    }
}

---

48ms

class Solution {
    func toGoatLatin(_ S: String) -> String {
                var str = ""
        let arr:[Character] = ["a","o","i","e","u"]
        let sarr = S.components(separatedBy: " ")
        
        for j in 0..<sarr.count {
            let x = sarr[j]
            var tolast = ""
            var a = ""
            for _ in 0..<j+1{
                a += "a"
            }
            
            var index = 0
            for y in x{
                if index == 0{
                    let z  = Character(String(y).lowercased())
                    if !arr.contains(z){
                        tolast = String(y)
                    }else{
                        str += String(y)
                    }
                }else{
                    str += String(y)
                }
                index += 1
            }
            
            if tolast != ""{
                str += tolast
            }
            
            str += "ma"
            str += a
            if j < sarr.count-1{
                str += " "
            }      
        }
        return str
    }
}