[Swift]LeetCode557. 反转字符串中的单词 III | Reverse Words in a String III

Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

Example 1:

Input: "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"

 Note: In the string, each word is separated by single space and there will not be any extra space in the string.

---

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:

输入: "Let's take LeetCode contest"
输出: "s'teL ekat edoCteeL tsetnoc" 

注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

---

空格：CharacterSet.whitespaces

376ms 

class Solution {
    func reverseWords(_ s: String) -> String {
        //按照空格分割，转换为数组
        var arr:[String] = s.components(separatedBy: " ")
        for i in 0..<arr.count
        {
            //反转单词
            arr[i] = String(arr[i].reversed())
        }
        //数组转换为字符串
        return arr.joined(separator: " ")
    }
}

---

84ms

class Solution {
    func reverseWords(_ s: String) -> String {
            func reverseString(_ s: String) -> String {
        
        var startIndex = 0
        var endIndex = s.count-1
        var array = s.cString(using:.utf8)!
        while startIndex<endIndex {
            let char = array[startIndex]
            array[startIndex] = array[endIndex]
            array[endIndex] = char
            startIndex+=1
            endIndex-=1
        }
        return String.init(utf8String: array)!
    }
    
    let array =  s.components(separatedBy: " ")
    var resultArray = [String]()
    for i in 0..<array.count {
        resultArray.append(reverseString(array[i]))
    }
    let result =  resultArray.joined(separator: " ")
    return result
    }
}

---

92ms

class Solution {
    func reverseWords(_ s: String) -> String {
        var result : String = ""
        var tempStr : String = ""
        var index = s.endIndex

        while index != s.startIndex {
            index = s.index(before: index)
            if s[index] == " " {
                result = tempStr+" "+result
                tempStr = ""
            }else{
                tempStr.append(s[index])
            }
        }
        if result.count>0 {
            result.removeLast()
            result = tempStr+" "+result
        }else{
            result = tempStr
        }
        return result
    }
}

---

 120ms

class Solution {
    func reverseWords(_ s: String) -> String {
        
        var result = ""
        let words = s.components(separatedBy: " ")
        
        for word in words {
            let reversedWord = String(word.characters.reversed()) + " "
            result.append(reversedWord)
            
        }
        return result.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

---

128ms

class Solution {
    func reverseWords(_ s: String) -> String {
        var strs = ""
        for str in s.components(separatedBy: " ") {
            strs.append(String(str.reversed()))
            strs.append(" ")
        }
        strs.removeLast()
        return strs   
    }
}

---

128ms

class Solution {
    func reverseWords(_ s: String) -> String {
        let arr = s.split(separator: " ").map {
            return $0.reversed()
        }
        
        var result = arr.reduce("", { $0 + " " + $1 })
        if !result.isEmpty {
            result.remove(at: result.startIndex)
        }
        return result
    }
}

---

328ms

class Solution {
    func reverseWords(_ s: String) -> String {
        return String(s.split(separator: " ").reduce("") { 
            $0 + $1.reversed() + " " 
        }.dropLast());
    }
}

---

720ms

class Solution {
    func reverseWords(_ s: String) -> String {
        let result = s.lazy.split(separator:" ").map{ $0.reversed()}.joined(separator:" ")
        return String(result)
    }
}

---

812ms

class Solution {
    func reverseWords(_ s: String) -> String {
        let array = (s.split(separator: " "))
        var temp: [String] = []
        for str in array {
            
            let chars: [Character] = [Character](str)
            temp.append(chars.reversed().map{String.init($0)}.joined())
        }
        return temp.joined(separator: " ")
    }
}