[Swift]LeetCode917. 仅仅反转字母 | Reverse Only Letters

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

Given a string S, return the "reversed" string where all characters that are not a letter stay in the same place, and all letters reverse their positions.

 

Example 1:

Input: "ab-cd"
Output: "dc-ba"

Example 2:

Input: "a-bC-dEf-ghIj"
Output: "j-Ih-gfE-dCba"

Example 3:

Input: "Test1ng-Leet=code-Q!"
Output: "Qedo1ct-eeLg=ntse-T!"

---

给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。

示例 1：

输入："ab-cd"
输出："dc-ba"

示例 2：

输入："a-bC-dEf-ghIj"
输出："j-Ih-gfE-dCba"

示例 3：

输入："Test1ng-Leet=code-Q!"
输出："Qedo1ct-eeLg=ntse-T!"

---

40ms

class Solution {
    func reverseOnlyLetters(_ S: String) -> String {
        //空字符串情况
        guard S != nil else {
            return S
        }
        //创建字典记录非字母
        var chars:[Int:Character] = [Int:Character]()
        //存储顺序字母
        var temp:String = String()
        //按索引遍历字符串
        for i in 0..<S.count
        {
            //获取字符
            let letter:Character = S[S.index(S.startIndex, offsetBy: i)]
            //判断字母
            if checkLetter(letter)
            {
                //存储字母
                temp.append(letter)
            }
            else
            {
                //记录非字母
                chars[i] = letter
            }
        }
        //字符串整体反转
        var result:String = String(temp.reversed())
        //创建等长度字符串数组
        var resultArray = Array(repeating:"", count: S.count)
        //判断记录是否为空
        if chars.isEmpty
        {
            return result
        }
        else
        {
            //遍历非字母
            for key in chars.keys
            {
                //填入非字母
                resultArray[key] = String(chars[key]!)
            }
            //遍历逆序字母
            for char in result
            {
                //遍历数组
                for j in 0..<resultArray.count
                {
                    //判断是否包含非字母
                    if String(resultArray[j]) == ""
                    {
                        //将逆序字母依次填入数组
                        resultArray[j] = String(char)
                        break
                    }
                }
            }
            //将数组转化为字符串
            result  = resultArray.joined(separator: "")
        }
        return result
    }
    //判断字母
    func checkLetter(_ char:Character)->Bool
    {
        var num:UInt32 = UInt32()
        for asc in char.unicodeScalars
        {
            num = asc.value
        }
        //65～90:A-Z
        //97~122:a-z
        if (num > 64 && num < 91) || (num > 96 && num < 123)
        {
            return true
        }
        else
        {
            return false
        }
    }
}

---

8ms

class Solution {
    func isAlpha(_ c: UInt8) -> Bool {
      return (97...122 ~= c) || (65...90 ~= c)
    }
    func reverseOnlyLetters(_ S: String) -> String {
      var sarr = Array(S.utf8)
      var b = 0, e = sarr.count-1
      while b < e {
        if !isAlpha(sarr[b]) {
          b += 1
        } else if !isAlpha(sarr[e]) {
          e -= 1
        } else {
          let t = sarr[b]
          sarr[b] = sarr[e]
          sarr[e] = t
          b += 1
          e -= 1
        }
      }
      return String(bytes: sarr, encoding: .utf8)!
    }
}

---

12ms

class Solution {
    func reverseOnlyLetters(_ S: String) -> String {
        var array :[Character] = Array(S)
        var startIndex = 0
        var endIndex = S.count - 1
        
        while endIndex > 0 && startIndex < S.count - 1 {
            while isLetter(c: array[startIndex]) == false && startIndex < S.count - 1 {
                startIndex += 1
            }
            
            while isLetter(c: array[endIndex]) == false && endIndex > 0 {
                endIndex -= 1
            }
            
            if startIndex > S.count - 1
                || endIndex <= 0 
                || startIndex >= endIndex {
                break
            }
            let tmp = array[endIndex]
            array[endIndex] = array[startIndex] 
            array[startIndex] = tmp
            startIndex += 1
            endIndex -= 1
        }
        return String(array)
    }
    
    func isLetter(c : Character) -> Bool {
        return  (c >= "a" && c <= "z") || 
        (c >= "A" && c <= "Z")
    }
}

---

16ms

class Solution {
     func reverseOnlyLetters(_ s: String) -> String {
        var arr = s.map({ String($0) })
        var arrCopy = arr
        var lastCount: Int = arr.count - 1
        for (index, string) in arr.enumerated() {
            //All elements looped
            guard lastCount >= index else {
                break
            }
            //Not special character
            guard string.lowercased() != string || string.uppercased() != string else {
                continue
            }
            while arr[lastCount].lowercased() == arr[lastCount],
                arr[lastCount].uppercased() == arr[lastCount] {
                lastCount -= 1
            }
            arrCopy.swapAt(index, lastCount)
            lastCount -= 1
        }
        return arrCopy.joined()
    }
}

---

20ms

class Solution {
    func reverseOnlyLetters(_ S: String) -> String {
        var array :[Character] = Array(S)
        var startIndex = 0
        var endIndex = S.count - 1
        
        while endIndex > 0 && startIndex < S.count - 1 {
            while isLetter(c: array[startIndex]) == false && startIndex < S.count - 1 {
                startIndex += 1
            }
            
            // if startIndex > S.count - 1 {
            //     break
            // }
            
            while isLetter(c: array[endIndex]) == false && endIndex > 0 {
                endIndex -= 1
            }
            
            if startIndex > S.count - 1
                || endIndex <= 0 
                || startIndex >= endIndex 
            {
                break
            }
            
            // if startIndex >= endIndex {
            //     break
            // }
            
            let tmp = array[endIndex]
            array[endIndex] = array[startIndex] 
            array[startIndex] = tmp
            print(String(array))
            
            startIndex += 1
            endIndex -= 1
        }
        
        return String(array)
    }
    
    func isLetter(c : Character) -> Bool {
        return  (c >= "a" && c <= "z") || 
        (c >= "A" && c <= "Z")
    }
}

28ms

class Solution {
    func reverseOnlyLetters(_ S: String) -> String {
        var array :[Character] = Array(S)
        var startIndex = 0
        var endIndex = S.count - 1
        
        while endIndex > 0 && startIndex < S.count - 1 {
            while isLetter(c: array[startIndex]) == false && startIndex < S.count - 1 {
                startIndex += 1
            }
            
            if startIndex > S.count - 1 {
                break
            }
            
            while isLetter(c: array[endIndex]) == false && endIndex > 0 {
                endIndex -= 1
            }
            
            
            if endIndex <= 0 {
                break
            }
            
            if startIndex >= endIndex {
                break
            }
            print("#####")
            print(startIndex)
            print(endIndex)
            
            let tmp = array[endIndex]
            array[endIndex] = array[startIndex] 
            array[startIndex] = tmp
            print(String(array))
            
            startIndex += 1
            endIndex -= 1
        }
        
        return String(array)
    }
    
    func isLetter(c : Character) -> Bool {
        return  (c >= "a" && c <= "z") || 
        (c >= "A" && c <= "Z")
    }
}

---

32ms

class Solution {
    func reverseOnlyLetters(_ S: String) -> String {
        
        var letters = [Character]()
        var alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
        
        var a = S.filter{alphabet.contains($0) == true}
        var ab = Array(a.reversed())
        var j = 0
        
        for (i, ch) in S.enumerated() {
            if !alphabet.contains(ch) {
                letters.append(ch)
            } else {
                letters.append(ab[j])
                j += 1
            }
        }        

        return String(letters)
    }
}

---

36ms

class Solution {
    func reverseOnlyLetters(_ S: String) -> String {
        
        var letters = [Character]()
        var alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
        
        var a = S.filter{alphabet.contains($0) == true}
        var ab = Array(a.reversed())
        var j = 0
        
        for (i, ch) in S.enumerated() {
            if !alphabet.contains(ch) {
                letters.append(ch)
            } else {
                letters.append(ab[j])
                j += 1
            }
        }
        
        print("ab: ", ab)
        

        return String(letters)
    }
}