【问题标题】:Comparing two arrays containing strings for anagrams in Ruby比较两个包含 Ruby 中字谜字符串的数组
【发布时间】:2015-01-17 14:27:32
【问题描述】:

如果我的代码关闭,请原谅我。我仍然对 Ruby on Rails 有所了解,随着我了解更多“只是 Ruby”,这似乎会出现细微的差异,但公平地说,我不确定我的代码是否能以 Ruby on Rails 格式通过集合.我跑题了。

我正在尝试比较两个包含一组字符串的数组。我想做几件事。 1) 确保数组的单词数相同,否则练习没有意义。 2) 比较数组中的第一个词与仅第二个数组中的第一个词。换句话说,我永远不想将数组“a”中的单词 1 与数组“b”中的单词 4 进行比较。我正在努力寻找一种解决方案,对任何给定单词中的字符进行重新排序,将其与第二个数组中相应单词中的重新排序字符进行比较,如果它是一个字谜,则打印 1(一旦排序,想法是这两个单词将是等效的)或 0 如果它们不匹配。

在下面的示例中,我想要打印的是:

0
0
1
1

...但这并没有发生。想法?恐怕这与局部变量问题有关,但我不确定。

    a = ['hello', 'goodbye', 'pants', 'baa']
    b = ['helio', 'godbye', 'spant', 'aba']

    x = a.length
    y = b.length
    z = 0

    x = y? do
        while z < x do
            if a.find(z).chars.sort.join == b.find(z).chars.sort.join
                puts 1
            else
                puts 0
            end

            z += 1
        end
    end

【问题讨论】:

  • 在 ruby​​ 中,如果您发现自己使用了 for、while 和 until 循环,那么您可能做错了。可用的迭代器非常强大,只需要一些时间来学习它们以及何时应用它们。
  • @Jeff Price 很高兴知道。我通常觉得编写循环很尴尬,但还远远不够,也许还没有意识到更强大的解决方案。
  • 我知道您是 SO 新手。将来,请考虑在选择答案之前等待更长时间。不要着急,快速选择可能会阻止其他可能更好的答案。此外,对于某些人来说,在他们仍在准备答案时看到绿色复选标记闪烁,这很可惜。一些海报在做出选择之前会等待数小时甚至一天。当然,有些人从不选择答案——即使已经发布了好的答案——这显然不是一件好事。
  • 只是认为应该注意的是,就效率而言,检查 2 个单词是否是字谜比排序和比较它们 O(nlogn) 更有效的方法。例如,您可以遍历每个单词,将第一个单词的该字符键处的哈希值增加 1,然后对第二个单词执行相同操作,但将值减少 1。然后,在所有这些之后,遍历哈希并查看是否有任何非零值,如果有,它们不是字谜 O(n)。
  • @raph,好点,我喜欢你建议的方法。但是,您可以跳过最后一步,前提是您事先检查了两个字符串的大小相同,无论如何这似乎是个好主意。那是因为如果任何字母的计数变为负数,您可以提前退出。如果这没有发生,那么在递减步骤之后,唯一的可能性是所有计数都为零。

标签: ruby arrays anagram


【解决方案1】:

[编辑:我已经编辑了我的答案,将@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'] #=&gt; 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=&gt;1、b=&gt;2、c=&gt;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,不是更清楚吗?

【讨论】:

  • 我的脑子有点乱。我刚刚找到了下一点的作业!感谢您的回答和后续步骤!
  • 感谢编辑...我研究了各种我不知道的方法(zip 方法是新的最爱!)但我必须说实话:我不遵循“字谜?”方法。第一行是废话……在那里跟踪。但是第二行...创建一个“计数”变量,该变量最终将存储一个散列,(为了安全起见)将数组中的每个单词小写,遍历每个字符,然后做什么? 'with_object' 方法让我着迷,坦率地说,我不明白 Hash.new 块是如何工作的。希望得到一些指导,让我更好地理解。
  • 我已经添加了解释。我通常这样做是为了让那些刚接触 Ruby 的人受益(尽管它们通常没有这篇文章那么长),但有时我会沉浸在问题中而忘记了观众。
  • 热狗!非常感谢。期望一些链接而不是完整的解释,但这非常有帮助!
【解决方案2】:

这不一定是火箭科学。事实上,只要你能一致地表示每个数组,这是不费吹灰之力的:

a = ['hello', 'goodbye', 'pants', 'baa']
b = ['helio', 'godbye', 'spant', 'aba']
c = ['lohel', 'goedboy', 'spant', 'aab']

def anagram_flatten(array)
  array.collect do |word|
    word.chars.sort.join
  end
end

puts anagram_flatten(a) == anagram_flatten(b)
# => false
puts anagram_flatten(a) == anagram_flatten(c)
# => true

当简单的数组与数组比较无论如何都超级快时,我不会担心部分比较。

【讨论】:

  • 谢谢,我明白你的意思了。虽然我的目标不是比较数组本身与数组中包含的单个项目,但部分比较对我来说实际上很重要。这个想法可能是我最终会计算两个(或 3 个或更多)数组中包含多少字谜并将其打印给用户,即“您的数组包含 2 个字谜”。显然不存在这种逻辑,但这就是想法......
  • 对不起,我不关注?我猜这个想法只是两个数组,其中包含任意数量的字符串。可以扩大范围,但最初只需要使用 2 个数组。
  • 对于A,B,C,D 和A,B,X,D,您希望结果是2 还是3?对于 A,B,D 和 A,D,结果是 1 还是 2?
【解决方案3】:

关于您的代码,只有两件事需要修复:

  • x = y? do 应该是if x == y
  • 你需要使用array[index]而不是array.find(index)(具体示例:a.find(z)和b.find(z)将分别变为a[z]和b[z])

这是您的代码,应用了这两个修复程序。它works:

a = ['hello', 'goodbye', 'pants', 'baa']
b = ['helio', 'godbye', 'spant', 'aba']

x = a.length
y = b.length
z = 0

if x == y
    while z < x do
        if a[z].chars.sort.join == b[z].chars.sort.join
            puts 1
        else
            puts 0
        end

        z += 1
    end
end

如需更多 ruby​​ 惯用的解决方案,请参阅 tadman's answer。

【讨论】:

  • 干杯。如果我有正确的语法会有帮助,不是吗?并感谢 ideone.com/ 的介绍,肯定会在工作中帮助我绕过防火墙:)
  • 小心不要从b 数组的末尾掉下来。如果b 包含的元素少于a,b[z] 将失败。
  • @tadman 当前受if x == y 条件保护
【解决方案4】:

好的,我找到了解决办法!

for i in 0..a.length-1
  a[i].chars.sort == b[i].chars.sort ? 1 : 0
end

输出

0
0
1
1

【讨论】:

  • 类似于 Cary 的第一个位:stackoverflow.com/posts/27027827/revisions。比我的原始版本更干净/简单。非常感谢您的提示!
  • 没问题。我很乐意提供帮助。我想提供一种有效的方法。
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2011-11-30
  • 1970-01-01
  • 1970-01-01
  • 2017-07-18
  • 2020-02-06
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多