[Swift]LeetCode821. 字符的最短距离 | Shortest Distance to a Character

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

Given a string S and a character C, return an array of integers representing the shortest distance from the character C in the string.

Example 1:

Input: S = "loveleetcode", C = 'e'
Output: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0] 

Note:

1. S string length is in [1, 10000].
2. C is a single character, and guaranteed to be in string S.
3. All letters in S and C are lowercase.

---

给定一个字符串 S 和一个字符 C。返回一个代表字符串 S 中每个字符到字符串 S 中的字符 C 的最短距离的数组。

示例 1:

输入: S = "loveleetcode", C = 'e'
输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]

说明:

1. 字符串 S 的长度范围为 [1, 10000]。
2. C 是一个单字符，且保证是字符串 S 里的字符。
3. S 和 C 中的所有字母均为小写字母。

---

16ms

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
        var sArray = Array(S)
        var ans = [Int]()
        
        var prev = Int.min/2
        for i in 0..<sArray.count {
            let char = sArray[i]
            if char == C {
                prev = i
            }
            ans.append(i-prev)
        }   
        prev = Int.max/2
        for i in stride(from: sArray.count-1, through: 0, by: -1) {
            let char = sArray[i]
            if char == C {
                prev = i
            }
            let minVal = min(ans[i], prev-i)
            ans[i] = minVal
    }    
        return ans
    }
}

---

20ms

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
        var results = Array(repeating: 0, count: S.count)
        
        var low = S.startIndex
        let high = S.firstIndex(where: { $0 == C })!
        
        while low < high {
            results[low.encodedOffset] = high.encodedOffset - low.encodedOffset
            
            low = S.index(after: low)
        }
        
        low = S.index(after: high)
        
        while case let hi = S[low..<S.endIndex].firstIndex(where: { $0 == C }),
            var hh = hi {
                var value = 1
                hh = S.index(before: hh)
                while low < hh {
                    results[low.encodedOffset] = value
                    results[hh.encodedOffset] = value
                    low = S.index(after: low)
                    hh = S.index(before: hh)
                    value += 1
                }
                if low == hh {
                    results[hh.encodedOffset] = value
                }
                low = S.index(after: hi!)
                
                if low == S.endIndex {
                    break
                }
        }
        
        var value = 1
        
        while low < S.endIndex {
            results[low.encodedOffset] = value
            value += 1
            low = S.index(after: low)
        }
        
        return results
    }
}

---

Runtime: 28 ms

Memory Usage: 19.6 MB

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
        let num:Int = S.count
        var res:[Int] = [Int](repeating:num,count:num)
        var arrChar = Array(S)
        for i in 0..<num
        {
            if arrChar[i] == C {res[i] = 0}
            else if i > 0
            {
                res[i] = res[i - 1] + 1
            }
        }
        for i in stride(from:num - 2,through:0,by:-1)
        {
            res[i] = min(res[i], res[i + 1] + 1)
        }
        return res
    }
}

---

28ms

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
        var forward = 0
        var backward = 0
        var first = true
        var result = [Int]()
        for char in S {
            forward += 1
            if char == C {
                while forward > 0 {
                    forward -= 1
                    backward += 1
                    if first {
                        result.append(forward)
                    } else {
                        result.append(min(forward, backward))
                    }
                }
                forward = 0
                backward = 0
                first = false
            }
        }
        while forward > 0 {
            forward -= 1
            backward += 1
            result.append(backward)
        }
        return result
    }
}

---

28ms

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
                var back = [Int]()
        var left = -1
        var right = -2
        for (index,t) in S.enumerated() {
            if t == C{
                if left < right { left = right }
                if right < index { right = index }
                for i in back.count...right{
                    let r = right - i
                    if left == -1 {
                        back.append(r)
                    }else{
                        let l = abs(left - i)
                        let m = min(l, r)
                        back.append(m)
                    }
                }
            }
        }
          if S.count - 1 > right {
            for i in 1..<S.count - right{
                back.append(i)
            }
        }
        return back
    }
}

---

36ms

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
        var a = [Int]()
        var indicies = [Int]()
        for (i,c) in S.unicodeScalars.enumerated() {
            if Character(c) == C {
                indicies.append(i)
            }
        }
        print(indicies)
        for i in 0..<S.count {
            var t = (-1,-1)
            var f = false
            for ind in indicies {
                if i < ind {
                    if t.0 == -1 {
                        t.0 = -5
                        t.1 = ind
                    } else {
                        t.1 = ind
                    }
                }
                if i > ind {
                    t.0 = ind
                }
                if ind == i {
                    f = true
                }
                if t.0 != -1 && t.1 != -1 {
                    // print(t)
                    break
                }
            }
            if f {
                a.append(0)
            } else if (t.0 == -1 && t.1 != -1) || t.0 == -5 {
                a.append(abs(t.1-i))
            } else if t.1 == -1 && t.0 != -1 {
                a.append(abs(t.0-i))
            } else {
                let ind = min(abs(t.0-i), abs(t.1-i))
                a.append(ind)
            }
        }
        
        return a
        
    }
}

---

36ms

class Solution {
    func shortestToChar(_ S: String, _ C: Character) -> [Int] {
        let chars = Array(S)
        let count = S.count
        var res = Array(repeating: 0, count: count)
        var currentPosition = -count

        for i in 0..<count {
            if chars[i] == C {
                currentPosition = i
            }
            res[i] = i - currentPosition
        }

        for i in Array(0..<count).reversed() {
            if chars[i] == C {
                currentPosition = i
            }
            res[i] = min(res[i], abs(currentPosition - i))
        }

        return res
    }
}

---

52ms

class Solution {
  func shortestToChar(_ S: String, _ C: Character) -> [Int] {
    let occurances = S.enumerated()
      .filter { (_, char) in return char == C }
      .map { (index, _ ) in index }
    
    var results: [Int] = Array(repeating: 0, count: S.count)
    for (index, _) in S.enumerated() {
      var result = Int.max
      occurances.forEach { occurance in
        let diff = abs(occurance - index)
        result = min(diff, result)
      }
      
      results[index] = result
    }
    
    return results
  }
}