[Swift]LeetCode3. 无重复字符的最长子串 | Longest Substring Without Repeating Characters

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

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

---

给定一个字符串，找出不含有重复字符的最长子串的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 无重复字符的最长子串是 "abc"，其长度为 3。

示例 2:

输入: "bbbbb"
输出: 1
解释: 无重复字符的最长子串是 "b"，其长度为 1。

示例 3:

输入: "pwwkew"
输出: 3
解释: 无重复字符的最长子串是 "wke"，其长度为 3。
     请注意，答案必须是一个子串，"pwke" 是一个子序列 而不是子串。

---

36ms

class Solution {
    func lengthOfLongestSubstring(_ s: String) -> Int {
        var m:[Int] = [Int](repeating: -1,count: 256)
        var res:Int = 0, left:Int = -1
        for i in 0..<s.count
        {
            let num:Int = s[s.index(s.startIndex,offsetBy: i)].toInt()
            left = max(left,m[num])
            m[num] = i
            res = max(res,i - left)
        }
        return res
    }
}
//Character扩展方法  
extension Character  
{  
    func toInt() -> Int  
    {  
        var num:Int = Int()
        for scalar in String(self).unicodeScalars  
        {  
            num = Int(scalar.value)  
        }  
        return num  
    }  
}

---

20ms

class Solution {
 func lengthOfLongestSubstring(_ s: String) -> Int {
     var right = 1
     var left = 0
     var i = 0
     var result = 0
     
     if s.count > 0 {
         result = right - left
         let chars = Array(s.utf8)
         
         //Interate in a incremental window 
         while right < chars.count {
             i = left
                while i < right {
                    //Check if a duplicate is found
                    if chars[i] == chars[right] {
                        left = i + 1
                        break
                    } 
                i = i + 1
             }
         result = max(result,right-left+1)     
         right = right + 1
     }
     }
     return result
     }
}

---

28ms

class Solution {
 func lengthOfLongestSubstring(_ s: String) -> Int {
        if s.characters.count == 0 {
            return 0
        }
        
        let chars = Array(s.utf8)
        var left = 0
        var right = 1
        var result = right - left
        var i = 0
        
        while right < chars.count {
            i = left
            while i < right {
                if chars[i] == chars[right] {
                    left = i + 1
                    break
                }
                i += 1
            }
            result = max(result, right - left + 1)
            right += 1
        }
        
        return result
    }
 }

---

36ms

class Solution {
    func lengthOfLongestSubstring(_ s: String) -> Int {
        var arr = [Int](repeating: -1, count: 256)
        var s = Array(s)
        var currentLength = 0
        var maxLength = 0
        for i in 0..<s.count {
            let cValue = Int(s[i].unicodeScalars.first!.value)
            let preIndex = arr[cValue]
            if arr[cValue] == -1 || i - preIndex > currentLength {
                currentLength += 1
            } else {
                maxLength = max(currentLength, maxLength)
                currentLength = i - preIndex
            }
            arr[cValue] = i
        }
        
        maxLength = max(currentLength, maxLength)
        return maxLength
    }
}

---

44ms

class Solution {
    func lengthOfLongestSubstring(_ s: String) -> Int {
        
        var last:[Int] = Array.init(repeating: -1, count: 127)
        var start: Int = 0 // 起始位置
        var maxLength: Int = 0  // 最大长度
        
        let chars: [Int8]? = s.cString(using: String.Encoding.utf8)
        
        for i in 0..<s.count {
            
            let hash_i: Int = Int(chars![i])
            let hash_null: Int = 0
            
            if (last[hash_i - hash_null] >= start) {
                maxLength = max(maxLength, i-start)
                start = last[hash_i - hash_null] + 1
            }
            last[hash_i - hash_null] = i
        }
        maxLength = max(maxLength, s.count - start)
        return maxLength
    }
}

---

52ms

class Solution {
    func lengthOfLongestSubstring(_ s: String) -> Int {
        let charArr = Array(s)
        let len = s.count
        var ans = 0
        var index = Array.init(repeating: 0, count: 128)
        var j = 0
        for i in 0..<len {
            let char = charArr[i]
            if let v = char.unicodeScalars.first?.value {
                j = max(index[Int(v)], j)
                ans = max(ans, i - j + 1)
                index[Int(v)] = i + 1
            }
        }
        return ans
    }
}

---

84ms

class Solution {
    func lengthOfLongestSubstring(_ s: String) -> Int {
        let cs = s.cString(using: .utf8)
        guard var chars = cs else { return 0 }
        guard chars.count > 1 else {
            return 0
        }
        chars.removeLast()
        var maxCount: Int = 0
        var i = 0, j = 0
        var map: [Int8: Int] = [:]
        while j < chars.count {
            if map.keys.contains(chars[j]) {
                i = max(map[chars[j]] ?? 0, i)
            }
            maxCount = max(maxCount, j - i + 1)
            map[chars[j]] = j + 1
            j += 1
        }
        return maxCount
    }
}