公认的答案简洁而优雅，但与其他解决方案相比效率非常低。
我现在将提出并讨论几个字谜检查器变体的实现。为了衡量性能，我将使用不同的变体从 50,000 多个单词的数组中找出给定单词的字谜。
// Variant 1: Sorting of Character
// Measured time: 30.46 s
func anagramCheck1(a: String, b: String) -> Bool {
return a.characters.sorted() == b.characters.sorted()
}
这本质上是接受答案的解决方案，用 Swift 3 语法编写。这很慢，因为 Swift 的 String 与 NSString 不同，它是基于 Character 的，它可以正确处理 Unicode 字符。
更有效的解决方案是利用 NSCountedSet 类，它允许我们将字符串表示为一组字符，每个字符都有自己的计数。如果两个字符串映射到同一个 NSCountedSet，则它们是字谜。
注意：检查字符串长度作为先决条件使得实现总是更高效。
// Variant 2: NSCountedSet of Character
// Measured time: 4.81 s
func anagramCheck2(a: String, b: String) -> Bool {
guard a.characters.count == b.characters.count else { return false }
let aSet = NSCountedSet()
let bSet = NSCountedSet()
for c in a.characters {
aSet.add(c)
}
for c in b.characters {
bSet.add(c)
}
return aSet == bSet
}
更好但不是很好。在这里，“罪魁祸首”之一是使用原生 Swift Character 类型（来自 Swift 的 String）。回到旧的 Objective-C 类型（NSString 和 unichar）可以让事情变得更有效率。
// Variant 3: NSCountedSet of unichar
// Measured time: 1.31 s
func anagramCheck3(a: String, b: String) -> Bool {
let aString = a as NSString
let bString = b as NSString
let length = aString.length
guard length == bString.length else { return false }
let aSet = NSCountedSet()
let bSet = NSCountedSet()
for i in 0..<length {
aSet.add(aString.character(at: i))
bSet.add(bString.character(at: i))
}
return aSet == bSet
}
使用 NSCountedSet 很好，但是在我们比较两个 NSCountedSet 对象之前，我们会完全填充它们。一个有用的替代方法是只为两个字符串中的一个完全填充 NSCountedSet，然后，当我们为另一个字符串填充 NSCountedSet 时，如果另一个字符串包含在第一个字符串的 NSCountedSet 中找不到的字符，我们会提前失败字符串。
// Variant 4: NSCountedSet of unichar and early exit
// Measured time: 1.07 s
func anagramCheck4(a: String, b: String) -> Bool {
let aString = a as NSString
let bString = b as NSString
let length = aString.length
guard length == bString.length else { return false }
let aSet = NSCountedSet()
let bSet = NSCountedSet()
for i in 0..<length {
aSet.add(aString.character(at: i))
}
for i in 0..<length {
let c = bString.character(at: i)
if bSet.count(for: c) >= aSet.count(for: c) {
return false
}
bSet.add(c)
}
return true
}
这是我们将获得的最佳时机（使用 Swift）。不过，为了完整起见，让我再讨论一个此类变体。
下一个替代方案利用 [unichar: Int] 类型的 Swift 字典来存储每个字符的重复次数，而不是 NSCountedSet。它比前两个变体稍慢，但我们可以稍后重用它以获得更快的实现。
// Variant 5: counting repetitions with [unichar:Int]
// Measured time: 1.36
func anagramCheck5(a: String, b: String) -> Bool {
let aString = a as NSString
let bString = b as NSString
let length = aString.length
guard length == bString.length else { return false }
var aDic = [unichar:Int]()
var bDic = [unichar:Int]()
for i in 0..<length {
let c = aString.character(at: i)
aDic[c] = (aDic[c] ?? 0) + 1
}
for i in 0..<length {
let c = bString.character(at: i)
let count = (bDic[c] ?? 0) + 1
if count > aDic[c] ?? 0 {
return false
}
bDic[c] = count
}
return true
}
请注意，使用 NSCountedSet 的 vanilla Objective-C 实现（对应于 Variant 3）比所有以前的版本都要快很多。
// Variant 6: Objective-C and NSCountedSet
// Measured time: 0.65 s
- (BOOL)anagramChecker:(NSString *)a with:(NSString *)b {
if (a.length != b.length) {
return NO;
}
NSCountedSet *aSet = [[NSCountedSet alloc] init];
NSCountedSet *bSet = [[NSCountedSet alloc] init];
for (int i = 0; i < a.length; i++) {
[aSet addObject:@([a characterAtIndex:i])];
[bSet addObject:@([b characterAtIndex:i])];
}
return [aSet isEqual:bSet];
}
我们可以改进之前尝试的另一种方法是观察，如果我们需要找到给定单词的字谜，我们不妨认为该单词是固定的，因此我们可以构建相应的结构 (NSCountedSet,字典，...）该单词仅一次。
// Finding all the anagrams of word in words
// Variant 7: counting repetitions with [unichar:Int]
// Measured time: 0.58 s
func anagrams(word: String, from words: [String]) -> [String] {
let anagrammedWord = word as NSString
let length = anagrammedWord.length
var aDic = [unichar:Int]()
for i in 0..<length {
let c = anagrammedWord.character(at: i)
aDic[c] = (aDic[c] ?? 0) + 1
}
let foundWords = words.filter {
let string = $0 as NSString
guard length == string.length else { return false }
var bDic = [unichar:Int]()
for i in 0..<length {
let c = string.character(at: i)
let count = (bDic[c] ?? 0) + 1
if count > aDic[c] ?? 0 {
return false
}
bDic[c] = count
}
return true
}
return foundWords
}
现在，在之前的变体中，我们使用 [unichar:Int] 字典进行计数。这证明比使用 unichar 的 NSCountedSet 稍微更有效，无论是提前退出（0.60 秒）还是不提前退出（0.87 秒）。