[编辑:我已经编辑了我的答案,将@raph 建议的效率改进纳入对问题的评论(方法anagram? 如下)。这可能没有必要,但我认为这是一个好主意,应该得到一些曝光。我也给出了详细的解释,因为 OP 是 Ruby 的新手,其他读者可能也是。]
你可以考虑如下做。
代码
def anagrams(a, b)
return nil unless a.size == b.size
a.zip(b).map { |aw,bw| anagram?(aw,bw) ? 1 : 0 }
end
def anagram?(aw, bw)
return false unless aw.size == bw.size
counts = aw.downcase.each_char.with_object(Hash.new(0)) { |c,h| h[c] += 1 }
bw.downcase.each_char do |c|
return false unless counts[c] > 0
counts[c] -= 1
end
true
end
示例
a = ['hello', 'goodbye', 'pants', 'baa']
b = ['helio', 'godbye', 'Spant', 'aba']
anagrams(a, b)
#=> [0, 0, 1, 1]
解释
anagrams方法
对于上面的例子,
a.size #=> 4
b.size #=> 4
所以我们不会在anagrams 的第一行返回nil。
接下来,
c = a.zip(b)
#=> [["hello", "helio"], ["goodbye", "godbye"],
# ["pants", "Spant"], ["baa", "aba"]]
暂时假设 anagram? 按预期工作:
c.map { |e| anagram?(e.first, e.last) ? 1 : 0 }
#=> [0, 0, 1, 1]
Enumerable#map 将c(一个二元素数组)的每个元素传递到块中。1。然而,更清楚的是,分解(或“消除歧义”)这些数组并将它们组成的两个单词中的每一个分配给一个块变量2:
c.map { |aw,bw| anagram?(aw,bw) ? 1 : 0 }
#=> [0, 0, 1, 1]
传入的第一个元素是["hello", "helio"],所以
aw => "hello"
bw #=> "helio"
我们执行
anagram?("hello", "helio") ? 1 : 0
#=> 0
这是的简写
if anagram?("hello", "helio")
1
else
0
end
#=> 0
anagram?方法
现在让我们继续anagram?,与
aw = "hello"
bw = "helio"
自从
aw.size == bw.size #=> true
我们不回来了。
计算第一个单词中字母的频率
现在让我写下 anagram? 的下面几行略有不同:
counts = Hash.new(0)
#=> {}
aw_down = aw.downcase
#=> "hello"
aw_down.each_char { |c| counts[c] += 1 }
#=> "hello"
counts
#=> {"h"=>1, "e"=>1, "l"=>2, "o"=>1}
(最后一行只是为了显示哈希值。)
在第一行中,我们创建了一个默认值为 0 的哈希 counts。这意味着如果counts 不包含键k,counts[k] 将返回默认值。 非常重要: 这样做不会改变哈希!3
String#each_char4 将"hello" 的每个字符传递到块中,并将其分配给块变量c。最初,c='h' 和 h={}。然后我们执行
counts['h'] += 1
这是的简写
counts['h'] = counts['h'] + 1
由于counts还没有键'h',所以右边的counts['h']返回默认值:
counts['h'] = 0 + 1 #=> 1
counts #=> {"h"=>1}
类似地,在 'e' 和第一个 'l' 被传递到块之后,我们有:
counts #=> {"h"=>1, "e"=>1, "l"=>1}
但是,当我们通过第二个'l' 时,我们执行
counts['l'] = counts['l'] + 1
#=> 1 + 1
#=> 2
我们完成了
counts #=> {"h"=>1, "e"=>1, "l"=>2, "o"=>1}
方法Enumerable#each_with_object会成为好朋友
此方法仅用于节省一些步骤。它允许我们写:
counts = Hash.new(0)
aw_down.each_char { |c| counts[c] += 1 }
作为
counts = aw_down.each_with_object(Hash.new(0)) { |c,h| h[c] += 1 }
我们也可以去掉这条线
aw_down = aw.downcase
通过写作
counts = aw.downcase.each_char.with_object(Hash.new(0)) { |c,h| h[c] += 1 }
这似乎节省了一点,但在许多其他情况下,使用each_with_object 和其他Enumerable 类方法允许链接方法,这非常有用。
减少第二个单词中字母的字母计数
回忆
counts #=> {"h"=>1, "e"=>1, "l"=>2, "o"=>1}
我们现在执行
bw_down = bw.downcase
#=> "helio"
"helio".each_char do |c|
return false unless counts[c] > 0
counts[c] -= 1
end
首先,'h' 被传递到块中。作为counts['h'] #=> 1,我们执行counts['h'] -= 1,所以现在
counts #=> {"h"=>0, "e"=>1, "l"=>2, "o"=>1}`.
在将'e' 和'l' 传递给块后,
counts #=> {"h"=>0, "e"=>0, "l"=>1, "o"=>1}
但是当我们通过'i'时,我们发现
counts['i'] #=> 0
(即返回默认值零,我们不想将counts['i'] 设置为-1)所以我们返回false,得出这两个词不是字谜的结论。 (如果第二个词是 "heeio",那么当第二个 'e' 传递给块时,我们会返回 false。)
我们有字谜吗?
由于两个词的长度相同,如果我们能够处理第二个词的所有字符而不返回false,我们必须以
结尾
counts #=> {"h"=>0, "e"=>0, "l"=>0, "o"=>0}
(无需检查!),这意味着这两个词是字谜,所以在这种情况下,我们会将true返回到anagrams。5 因此,anagram? 的最后一行.
备注
1 在幕后,这就是正在发生的事情:
enum = c.map
#=> #<Enumerator: [["hello", "helio"], ["goodbye", "godbye"],
# ["pants", "Spant"], ["baa", "aba"]]:map>
在这里我们可以看到枚举器将传递到块中的元素,但有时您需要将枚举器转换为数组才能获取该信息:
enum.to_a
#=> [["hello", "helio"], ["goodbye", "godbye"],
# ["pants", "Spant"], ["baa", "aba"]]
实际上是Array#each方法将enum的元素传入块中:
enum.each { |aw,bw| anagram?(aw,bw) ? 1 : 0 }
#=> [0, 0, 1, 1]
2 如果我们将[[1,2],3] 传递到一个块中,并且块变量写入|(a,b),c|,那么a=>1、b=>2、c=>3。这很方便。很酷,嗯?
3
h = Hash.new('pig')
h['dog'] = 7 #=> 7
h #=> {"dog"=>7}
h[0] #=> "pig"
h['cat'] #=> "pig"
h[{:a=>1}] #=> "pig"
h #=> {"dog"=>7}
请注意,Hash#new 有一种形式,它接受块,它允许在引用时添加不在散列中的键。
4 我们可以写成aw_down.chars.each,而不是aw_down.each_char,但是aw_down.chars 创建了一个不必要的中间数组。 each_char,一个枚举器,只是传递需要的值。
5我们可以返回0而不是false和1而不是true,在这种情况下我们可以写
a.zip(b).map { |aw,bw| anagram?(aw,bw) }
在anagrams 中,但是让anagrams 返回一个值为true 或false 的数组,而不是0 或1,不是更清楚吗?