[Swift]LeetCode763. 划分字母区间 | Partition Labels

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

A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts. 

Example 1:

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

Note:

1. S will have length in range [1, 500].
2. S will consist of lowercase letters ('a' to 'z') only.

---

Runtime: 20 ms

Memory Usage: 20 MB

class Solution {
    func partitionLabels(_ S: String) -> [Int] {
        var res:[Int] = [Int]()
        var n:Int = S.count
        var start:Int = 0
        var last:Int = 0
        var m:[Character:Int] = [Character:Int]()
        var arr:[Character] = Array(S)
        for i in 0..<n
        {
            m[arr[i]] = i
        }
        for i in 0..<n
        {
            last = max(last, m[arr[i],default:0])
            if i == last
            {
                res.append(i - start + 1)
                start = i + 1
            }
        }
        return res
    }
}

---

20ms

class Solution {
func partitionLabels(_ S: String) -> [Int] {
    let arr = Array(S)
    var dict:[Character:Int] = [:]
    
    for i in 0 ..< arr.count {
        dict[arr[i]] = i
    }
    
    var result :[Int] = []
    var temp: Int = 0
    var index: Int = 0
    while index < arr.count {
        temp = dict[arr[index]]!
        index += 1
        while index <= temp {
            if dict[arr[index]]! > temp {
                temp = dict[arr[index]]!
            }
            index += 1
        }
        result.append(temp+1 - result.reduce(0,+))
    }
    
    return result
  }
}

---

20ms

class Solution {    
    func partitionLabels(_ S: String) -> [Int] {
        var stringEndDic : [Int] = Array(repeating: -1, count: 128)

        var idx : Int = 0
        for unicode in S.unicodeScalars {
            stringEndDic[Int(unicode.value)] = idx
            idx += 1
        }
        
        var begin : Int = 0
        var end : Int = 0
        
        var result:[Int] = []
        
        idx = 0
        for unicode in S.unicodeScalars {
            if end < stringEndDic[Int(unicode.value)] {
                end = stringEndDic[Int(unicode.value)]
            }
            idx += 1
            if idx > end{
                result.append(idx-begin)
                begin = idx
                end = idx
            }
        }
        
        return result
    }
}

---

24ms

class Solution {
    func partitionLabels(_ s: String) -> [Int] {
    var hash = Array(repeating: (-1, -1), count: 26)
    for (i, char) in s.unicodeScalars.enumerated() {
        let n = Int(char.value) - 97
        if hash[n].0 == -1 {
            hash[n] = (i, i)
        } else {
            hash[n].1 = i
        }
    }
    
    var index = 0
    while index < hash.count {
        if hash[index].0 == -1 {
            hash.remove(at: index)
        } else {
            index += 1
        }
    }
    hash.sort { $0.0 < $1.0 }
    
    var ans = [Int]()
    var maxIndex = 0
    var minIndex = 0
    
    for (start, end) in hash {
        
        if start > maxIndex {
            ans.append(maxIndex - minIndex + 1)
            maxIndex = end
            minIndex = start
        } else {
            maxIndex = max(maxIndex, end)
        }
    }
    
    ans.append(maxIndex - minIndex + 1)
    return ans
    }
}

---

24ms

class Solution {
    func partitionLabels(_ S: String) -> [Int] {
        let S = S.map{$0}
        var dict = [Character:Int]()
        
        var index = 0
        for char in S {
            dict[char] = index
            index += 1
        }
        
        var ans = [Int]()
        var maxIndex = 0; var tmpIndex = -1
        index = 0
        for char in S {
            maxIndex = max(maxIndex, dict[char]!)
            if (index == maxIndex) {
                ans.append(index - tmpIndex)
                tmpIndex = index
            }
            index += 1
        }
        
        return ans
    }
}

---

40ms

class Solution {    
    func partitionLabels(_ S: String) -> [Int] {
        var dict = [String: Int]()
        for (index, item) in Array(S).enumerated() {
            dict[String(item)] = index
        }
        var returnArr = [Int]()
        var maxIndex = 0
        var anchor = 0
        for (index, item) in Array(S).enumerated() {
            guard let indexInDict = dict[String(item)] else {
                continue
            }
            maxIndex = max(maxIndex, indexInDict)
            if index == maxIndex {
                returnArr.append(index-anchor+1)
                anchor = index+1
            }
        }
        return returnArr
    }
}