[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 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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]) 
    }
}