[Swift]LeetCode833. 字符串中的查找与替换 | Find And Replace in String

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

To some string S, we will perform some replacement operations that replace groups of letters with new ones (not necessarily the same size).

Each replacement operation has 3parameters: a starting index i, a source word x and a target word y.  The rule is that if x starts at position i in the originalstring S, then we will replace that occurrence of x with y.  If not, we do nothing.

For example, if we have S = "abcd" and we have some replacement operation i = 2, x = "cd", y = "ffff", then because "cd" starts at position 2 in the original string S, we will replace it with "ffff".

Using another example on S = "abcd", if we have both the replacement operation i = 0, x = "ab", y = "eee", as well as another replacement operation i = 2, x = "ec", y = "ffff", this second operation does nothing because in the original string S[2] = 'c', which doesn't match x[0] = 'e'.

All these operations occur simultaneously.  It's guaranteed that there won't be any overlap in replacement: for example, S = "abc", indexes = [0, 1], sources = ["ab","bc"] is not a valid test case.

Example 1:

Input: S = "abcd", indexes = [0,2], sources = ["a","cd"], targets = ["eee","ffff"]
Output: "eeebffff"
Explanation: "a" starts at index 0 in S, so it's replaced by "eee".
"cd" starts at index 2 in S, so it's replaced by "ffff".

Example 2:

Input: S = "abcd", indexes = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"]
Output: "eeecd"
Explanation: "ab" starts at index 0 in S, so it's replaced by "eee". 
"ec" doesn't starts at index 2 in the original S, so we do nothing.

Notes:

1. 0 <= indexes.length = sources.length = targets.length <= 100
2. 0 < indexes[i] < S.length <= 1000
3. All characters in given inputs are lowercase letters.

---

对于某些字符串 S，我们将执行一些替换操作，用新的字母组替换原有的字母组（不一定大小相同）。

每个替换操作具有 3 个参数：起始索引 i，源字 x 和目标字 y。规则是如果 x 从原始字符串 S 中的位置 i 开始，那么我们将用 y 替换出现的 x。如果没有，我们什么都不做。

举个例子，如果我们有 S = “abcd” 并且我们有一些替换操作 i = 2，x = “cd”，y = “ffff”，那么因为 “cd” 从原始字符串 S 中的位置 2 开始，我们将用 “ffff”替换它。

再来看 S = “abcd” 上的另一个例子，如果我们有替换操作 i = 0，x = “ab”，y = “eee”，以及另一个替换操作 i = 2，x = “ec”，y = “ffff”，那么第二个操作将不执行任何操作，因为原始字符串中 S[2] = 'c'，与 x[0] = 'e' 不匹配。

所有这些操作同时发生。保证在替换时不会有任何重叠： S = "abc", indexes = [0, 1], sources = ["ab","bc"] 不是有效的测试用例。

示例 1：

输入：S = "abcd", indexes = [0,2], sources = ["a","cd"], targets = ["eee","ffff"]
输出："eeebffff"
解释：
"a" 从 S 中的索引 0 开始，所以它被替换为 "eee"。
"cd" 从 S 中的索引 2 开始，所以它被替换为 "ffff"。

示例 2：

输入：S = "abcd", indexes = [0,2], sources = ["ab","ec"], targets = ["eee","ffff"]
输出："eeecd"
解释：
"ab" 从 S 中的索引 0 开始，所以它被替换为 "eee"。
"ec" 没有从原始的 S 中的索引 2 开始，所以它没有被替换。 

提示：

1. 0 <= indexes.length = sources.length = targets.length <= 100
2. 0 < indexes[i] < S.length <= 1000
3. 给定输入中的所有字符都是小写字母。

---

36ms

final class Solution {
    func findReplaceString(_ S: String, _ indexes: [Int], _ sources: [String], _ targets: [String]) -> String {
        var dict: [Int: (String, String)] = Dictionary(uniqueKeysWithValues: zip(indexes, zip(sources, targets)) )
        var indexes = indexes.sorted(by: >)
        var S = Array(S)
        var res = S
        for index in indexes {
            let val = dict[index]!
            let source = Array(val.0)
            let target = Array(val.1)
            if hasOccurence(S, source, index) {
                res.replaceSubrange(index..<(index &+ source.count), with: target)
            }
        }
        return String(res)
    }
    
    @inline(__always) private func hasOccurence(_ S: [Character], _ source: [Character], _ index: Int) -> Bool {
        for i in index..<(index + source.count) {
            if i >= S.count { return false }
            if S[i] != source[i - index] { return false }
        }
        return true
    }
}

---

40ms

class Solution {    
    struct StringReplaceIndex: Comparable {
        let index: Int
        let source: String
        let target: String

        static func < (lhs: StringReplaceIndex, rhs: StringReplaceIndex) -> Bool {
            return lhs.index < rhs.index
        }
    }

    func findReplaceString(_ S: String, _ indices: [Int], _ sources: [String], _ targets: [String]) -> String {
        // build the replace indices in sorted order
        var replaceIndices = [StringReplaceIndex]()
        for i in 0..<indices.count {
            replaceIndices.append(StringReplaceIndex(index: indices[i], source: sources[i], target: targets[i]))
        }
        replaceIndices.sort()

        var result = [String]()

        // need to handle the substring when the indices doesn't start from 0
        if replaceIndices[0].index != 0 {
            let subString = S.subString(from: 0, to: replaceIndices[0].index - 1)
            result.append(subString)
        }

        for i in 0..<replaceIndices.count {
            let startIndex = replaceIndices[i].index
            let endIndex = ((i+1) < replaceIndices.count) ? replaceIndices[i+1].index - 1 : S.count - 1
            var subString = S.subString(from: startIndex, to: endIndex)
            if subString.hasPrefix(replaceIndices[i].source) {
                subString.removeFirst(replaceIndices[i].source.count)
                subString = replaceIndices[i].target + subString
            }
            result.append(subString)
        }
        return result.reduce("", +)
    }        
}
    
extension String {

    subscript(i: Int) -> Character {
        get {
            return self[index(startIndex, offsetBy: i)]
        }
    }

    func subString(from: Int, to: Int) -> String {
        guard from <= to else {
            return ""
        }

        let startIndex = self.index(self.startIndex, offsetBy: from)
        let endIndex = self.index(self.startIndex, offsetBy: to)
        return String(self[startIndex...endIndex])
    }

    func subString(from: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: from)
        return String(self.suffix(from: startIndex))
    }

    func asciiValues() -> [Int] {
        return Array(self.utf16).map { Int($0) }
    }

    mutating func lTrim(_ regex: String = "^\\s+") {
        if let trailingSpacesRange = self.range(of: regex, options: .regularExpression) {
            self.replaceSubrange(trailingSpacesRange, with: "")
        }
    }

    mutating func rTrim(_ regex: String = "\\s+$") {
        if let trailingSpacesRange = self.range(of: regex, options: .regularExpression) {
            self.replaceSubrange(trailingSpacesRange, with: "")
        }
    }

    func stringByReplacingAt(_ index: Int, with ch: Character) -> String {
        var chars = Array(self)
        chars[index] = ch
        let modifiedString = String(chars)
        return modifiedString
    }
}

---

48ms

class Solution {
    private struct ConfirmedReplacement {
        let start: String.Index
        let end: String.Index
        let target: String
    }
    
    func findReplaceString(_ S: String, _ indexes: [Int], _ sources: [String], _ targets: [String]) -> String {
        var confirmedTargets: [ConfirmedReplacement] = []
        //1. confirm
        for i in 0..<indexes.count {
            let start = S.index(S.startIndex, offsetBy: indexes[i])
            let source = sources[i]
            let end = S.index(start, offsetBy: source.count)
            let target = targets[i]
            if S[start..<end] != source {
                continue
            }
            let confirmed = ConfirmedReplacement(start: start, end: end, target: target)
            confirmedTargets.append(confirmed)
        }
        //2. sort confirmed range
        confirmedTargets = confirmedTargets.sorted(by: { (lhs, rhs) -> Bool in
            return rhs.start > lhs.start
        })
        //3. fill string
        var strFragments: [String] = []
        var index = S.startIndex
        for target in confirmedTargets {
            strFragments.append(String(S[index..<target.start]))
            strFragments.append(target.target)
            index = target.end
        }
        strFragments.append(String(S[index..<S.endIndex]))
        return strFragments.joined()
    }
}

---

Runtime: 60 ms

Memory Usage: 19.7 MB

class Solution {
    func findReplaceString(_ S: String, _ indexes: [Int], _ sources: [String], _ targets: [String]) -> String {
        var S = S
        var v:[[Int]] = [[Int]]()
        for i in 0..<indexes.count
        {
            v.append([indexes[i], i])
        }
        v.sort(by:{(a:[Int],b:[Int]) -> Bool in 
                   if a[0] == b[0]
                   {
                       return a[1] >= b[1]
                   }
                   else
                   {
                       return a[0] > b[0]
                   }
                  })
        for a in v
        {
            var i:Int = a.first!
            var str:String = sources[a[1]]
            var t:String = targets[a[1]]
            if S.subString(i, str.count) == str
            {
                S = S.subString(0, i) + t + S.subString(i + str.count)
            }
        }
        return S
    }
}

extension String {
    // 截取字符串：从index到结束处
    // - Parameter index: 开始索引
    // - Returns: 子字符串
    func subString(_ index: Int) -> String {
        let theIndex = self.index(self.endIndex, offsetBy: index - self.count)
        return String(self[theIndex..<endIndex])
    }
    
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
}