Question

我在Swift中有一个函数来计算两个字符串的hamming distance，然后如果结果为1则将它们放入连接图中。

例如，读取到听取会返回汉明距离2，因为 read[0] != hear[0] 和 { {1}} 即可。

起初，我认为我的功能花了很长时间，因为输入的数量（8,000+单词字典），但我知道几分钟太长了。所以，我用Java重写了我的相同算法，计算只需0.3秒。

我尝试用两种不同的方式在Swift中写这个：

方式1 - 子串

read[3] != hear[3]

结果： 434秒

方式2 - 删除字符

extension String {

    subscript (i: Int) -> String {
        return self[Range(i ..< i + 1)]
    }

}

private func getHammingDistance(w1: String, w2: String) -> Int {
    if w1.length != w2.length { return -1 }

    var counter = 0
    for i in 0 ..< w1.length {
        if w1[i] != w2[i] { counter += 1 }
    }

    return counter
}

结果： 156秒

Java中的相同内容

结果： 0.3秒

被称为

的地方

private func getHammingDistance(w1: String, w2: String) -> Int {
    if w1.length != w2.length { return -1 }

    var counter = 0
    var c1 = w1, c2 = w2      // need to mutate
    let length = w1.length

    for i in 0 ..< length {
        if c1.removeFirst() != c2.removeFirst() { counter += 1 }
    }

    return counter
}

对我来说，156秒的效率仍然太低。在Swift中比较字符的绝对最有效的方法是什么？是否有可能的计算汉明距离的解决方法，而不是比较字符？

修改

编辑1：我正在读一个包含4个和5个字母单词的完整字典，并创建一个连接图表，其中边缘表示汉明距离为1.因此，我将比较8,000多个单词另一个是生成边缘。

编辑2 已添加方法调用。

Answer 1

试试这个：

extension String {
    func hammingDistance(to other: String) -> Int? {
        guard self.characters.count == other.characters.count else { return nil }

        return zip(self.characters, other.characters).reduce(0) { distance, chars in
            distance + (chars.0 == chars.1 ? 0 : 1)
        }
    }
}

print("read".hammingDistance(to: "hear")) // => 2

Answer 2

以下代码以0.07分为单位执行8500个字符：

func getHammingDistance(w1: String, w2: String) -> Int {
    if w1.characters.count != w2.characters.count {
        return -1
    }

    let arr1 = Array(w1.characters)
    let arr2 = Array(w2.characters)

    var counter = 0
    for i in 0 ..< arr1.count {
        if arr1[i] != arr2[i] { counter += 1 }
    }

    return counter
}

Answer 3

除非为字符串选择固定长度的字符模型，否则方法和属性（如.count和.characters）的复杂度为O（n）或最多为O（n / 2）（其中n为字符串长度））。如果您要将数据存储在一个字符数组中（例如[Character]），那么您的函数会表现得更好。

您还可以使用zip（）函数

在一次传递中组合整个计算

let hammingDistance = zip(word1.characters,word2.characters)
                      .filter{$0 != $1}.count

但仍然需要遍历每个单词对的所有字符。

...

鉴于你只是寻找汉明距离为1，有一种更快捷的方式来获得所有独特的单词：

策略是按照与一个“缺失”字母对应的4（或5）个模式对单词进行分组。这些模式组中的每一个都定义了较小的单词对范围，因为不同组中的单词的距离不是1。

每个单词将属于与其字符数一样多的组。

例如：

"hear" will be part of the pattern groups:
"*ear", "h*ar", "he*r" and "hea*".

与这4个模式组中的一个对应的任何其他单词将与“听到”的汉明距离为1。

以下是如何实施：

// Test data 8500 words of 4-5 characters ...
var seenWords = Set<String>()
var allWords = try! String(contentsOfFile: "/usr/share/dict/words")
                     .lowercased()                        
                     .components(separatedBy:"\n")
                     .filter{$0.characters.count == 4 || $0.characters.count == 5}
                     .filter{seenWords.insert($0).inserted}
                     .enumerated().filter{$0.0 < 8500}.map{$1}

// Compute patterns for a Hamming distance of 1
// Replace each letter position with "*" to create patterns of
// one "non-matching" letter
public func wordH1Patterns(_ aWord:String) -> [String]
{
   var result       : [String]    = []
   let fullWord     : [Character] = aWord.characters.map{$0}
   for index in 0..<fullWord.count
   {
      var pattern    = fullWord
      pattern[index] = "*" 
      result.append(String(pattern))                     
   }
   return result
}

// Group words around matching patterns
// and add unique pairs from each group
func addHamming1Edges()
{
   // Prepare pattern groups ...
   // 
   var patternIndex:[String:Int] = [:]
   var hamming1Groups:[[String]]  = []
   for word in allWords
   {
      for pattern in wordH1Patterns(word)
      {
         if let index = patternIndex[pattern]
         { 
           hamming1Groups[index].append(word) 
         }
         else
         {
           let index = hamming1Groups.count
           patternIndex[pattern] = index
           hamming1Groups.append([word])
         }        
      }
   }

   // add edge nodes ...
   //
   for h1Group in hamming1Groups
   {
       for (index,sourceWord) in h1Group.dropLast(1).enumerated()
       {
          for targetIndex in index+1..<h1Group.count
          { addEdge(source:sourceWord, neighbour:h1Group[targetIndex]) } 
       }
   }
}

在我的2012 MacBook Pro上，8500个单词在0.12秒内通过22817（独特）边缘对。

[编辑]为了说明我的第一点，我使用字符数组而不是字符串制作了一个“蛮力”算法：

   let wordArrays = allWords.map{Array($0.unicodeScalars)}
   for i in 0..<wordArrays.count-1
   {
      let word1 = wordArrays[i]
      for j in i+1..<wordArrays.count
      {
         let word2 = wordArrays[j]
         if word1.count != word2.count { continue }

         var distance = 0
         for c in 0..<word1.count 
         {
            if word1[c] == word2[c] { continue }
            distance += 1
            if distance > 1 { break }
         }
         if distance == 1
         { addEdge(source:allWords[i], neighbour:allWords[j]) }
      }
   }

这通过0.27秒的独特对。速度差异的原因是Swift Strings的内部模型，它实际上不是等长元素（字符）的数组，而是一串不同长度的编码字符（类似于UTF模型，其中特殊字节表示以下2或3个字节是单个字符的一部分。没有简单的Base + Displacement索引这样的结构，必须始终从头开始迭代到第N个元素。

请注意，我使用unicodeScalars而不是Character，因为它们是16位固定长度的字符表示形式，允许直接二进制比较。字符类型不是那么简单，需要更长的时间进行比较。

Answer 4

经过一番捣乱，我找到了一个更快的解决方案@ Alexander的回答（以及我之前的错误答案）

extension String {
    func hammingDistance(to other: String) -> Int? {
        guard !self.isEmpty, !other.isEmpty, self.characters.count == other.characters.count else {
            return nil
        }

        var w1Iterator = self.characters.makeIterator()
        var w2Iterator = other.characters.makeIterator()

        var distance = 0;
        while let w1Char = w1Iterator.next(), let w2Char = w2Iterator.next()  {
            distance += (w1Char != w2Char) ? 1 : 0
        }
        return distance
    }
}

为了比较具有一百万个字符的字符串，在我的机器上它是1.078秒而不是1.220秒，因此大约提高了10％。我猜这是因为避免了.zip以及.reduce和元组的轻微开销

Answer 5

*破*，见新答案

我的方法：

private func getHammingDistance(w1: String, w2: String) -> Int {
    guard w1.characters.count == w2.characters.count else {
        return -1
    }
    let countArray: Int = w1.characters.indices
        .reduce(0, {$0 + (w1[$1] == w2[$1] ? 0 : 1)})
    return countArray
}

比较2个10,000个随机字符的字符串需要0.31秒

要进行扩展：它应该只需要对字符串进行一次迭代，然后按原样添加。

此外，它更简洁。

Answer 6

正如其他人所说，重复调用.characters需要时间。如果你将所有字符串转换一次，它应该有所帮助。

func connectData() {
    let verticies = graph.canvas // canvas is Array<Node>
                                 // Node has key that holds the String
    // Convert all of the keys to utf16, and keep them
    let nodesAsUTF = verticies.map { $0.key!.utf16 }

    for vertex in 0 ..< verticies.count {
        for compare in vertex + 1 ..< verticies.count {
            if getHammingDistance(w1: nodesAsUTF[vertex], w2: nodesAsUTF[compare]) == 1 {
                graph.addEdge(source: verticies[vertex], neighbor: verticies[compare])
            }
        }
    }
}

// Calculate the hamming distance of two UTF16 views
func getHammingDistance(w1: String.UTF16View, w2: String.UTF16View) -> Int {
    if w1.count != w2.count {
        return -1
    }

    var counter = 0
    for i in w1.startIndex ..< w1.endIndex {
        if w1[i] != w1[i] {
            counter += 1
        }
    }
    return counter
}

我使用的是UTF16，但您可能需要尝试使用UTF8，具体取决于数据。由于我没有您正在使用的词典，请告诉我结果！

如何有效地比较Swift中的字符

方式1 - 子串

方式2 - 删除字符

Java中的相同内容

被称为

修改

6 个答案: