优化将破折号添加到长 Swift 字符串

Question

我正在尝试使用十六进制字符串并在每个其他字符之间插入破折号（例如“b201a968”到“b2-01-a9-68”）。我找到了几种方法来做到这一点，但问题是我的字符串相当大（8066 个字符），而且我可以让它工作的最快速度仍然需要几秒钟。这些是我尝试过的方法以及它们需要多长时间。谁能帮我优化一下这个功能？

//42.68 seconds
    func reformatDebugString(string: String) -> String
    {
        var myString = string
        var index = 2
        while(true){
            myString.insert("-", at: myString.index(myString.startIndex, offsetBy: index))
            index += 3
            if(index >= myString.characters.count){
                break
            }
        }

        return myString
    }

---

//21.65 seconds
    func reformatDebugString3(string: String) -> String
    {
        var myString = ""
        let length = string.characters.count
        var first = true
        for i in 0...length-1{
            let index = string.index(myString.startIndex, offsetBy: i)
            let c = string[index]

            myString += "\(c)"
            if(!first){
                myString += "-"
            }
            first = !first
        }

        return myString
    }

---

//11.37 seconds
    func reformatDebugString(string: String) -> String
    {
        var myString = string
        var index = myString.characters.count - 2
        while(true){
            myString.insert("-", at: myString.index(myString.startIndex, offsetBy: index))
            index -= 2
            if(index == 0){
                break
            }
        }

        return myString
    }

Answer 1

所有三种方法的问题是使用index(_:offsetBy:) 来获取循环中当前字符的索引。这是一个 O(n) 运算，其中 n 是要偏移的距离 - 因此使您的所有三个函数都以二次时间运行。

此外，对于解决方案 #1 和 #3，插入结果字符串是一个 O(n) 操作，因为插入点之后的所有字符都必须向上移动以容纳添加的字符。在这种情况下，从头开始构建字符串通常更便宜，因为我们可以在字符串的末尾添加一个给定的字符，如果字符串有足够的容量，则为 O(1)，否则为 O(n)。

对于解决方案 #1，说 myString.characters.count 是一个 O(n) 操作，所以不是您希望在循环的每次迭代中都做的事情。

因此，我们希望从头开始构建字符串，并避免在循环内索引和计算字符数。这是这样做的一种方法：

extension String {

    func addingDashes() -> String {

        var result = ""

        for (offset, character) in characters.enumerated() {

            // don't insert a '-' before the first character,
            // otherwise insert one before every other character.
            if offset != 0 && offset % 2 == 0 {
                result.append("-")
            }

            result.append(character)
        }
        return result
    }
}

// ...

print("b201a968".addingDashes()) // b2-01-a9-68

您在发布版本中的最佳解决方案（#3）在我的计算机上花费了 37.79 秒，上面的方法花费了 0.023 秒。

Answer 2

正如 Hamish 的回答中已经指出的，您应该避免这两件事：

• 用string.index(string.startIndex, offsetBy: ...)计算每个索引
• 用insert(_:at:)修改一个大字符串

所以，这可以是另一种方式：

func reformatDebugString4(string: String) -> String {
    var result = ""

    var currentIndex = string.startIndex
    while currentIndex < string.endIndex {
        let nextIndex = string.index(currentIndex, offsetBy: 2, limitedBy: string.endIndex) ?? string.endIndex
        if currentIndex != string.startIndex {
            result += "-"
        }
        result += string[currentIndex..<nextIndex]
        currentIndex = nextIndex
    }

    return result
}