比较Ruby中两个包含字谜字符串的数组

如果我的密码关闭了，请原谅我。我仍然对RubyonRails很感兴趣，随着我对“JustRuby”的了解越来越多，它似乎有着微妙的区别，不过公平地说，我不确定我的代码是否能通过RubyonRails格式的测试。我离题了

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

在下面的示例中，我希望它打印的是：

0
0
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

a=['hello'，'bye'，'pants'，'baa']
b=['helio'，'Godbay'，'spant'，'aba']
x=a.长度
y=b.长度
z=0
x=y？做
当z

这不一定是火箭科学。事实上，只要您能够始终如一地表示每个数组，就不需要动脑筋：

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

---

当简单数组与数组比较非常快时，我不会担心部分比较。

关于您的代码，只有两件事需要解决：

• 行

  x=y？如果x==y，do

  应该是

• 代替

  array.find（index）

  您需要使用

  array[index]

  （具体示例：

  a.find（z）

  和

  b.find（z）

  将分别变成

  a[z]

  和

  b[z]

  ）

这是您的代码，应用了这两个修复程序。它：

a=['hello'，'bye'，'pants'，'baa']
b=['helio'，'Godbay'，'spant'，'aba']
x=a.长度
y=b.长度
z=0
如果x==y
当z

有关更为ruby惯用的解决方案，请参见。

[编辑：我已编辑了我的答案，以将@raph建议的效率改进纳入对该问题的评论中（下面的方法

anagram？

）。这可能没有必要，但我认为这是一个好主意，它应该得到一些曝光。我也给出了详细的解释，因为这篇文章对Ruby来说是新的，其他读者可能也是如此。]

你可以考虑这样做。

代码

示例

解释

字谜

方法

就上面的例子来说,

a.size #=> 4
b.size #=> 4

因此，在

字谜的第一行中，我们不返回
nil

其次,

假设
字谜？
按预期工作：

c.map { |e| anagram?(e.first, e.last) ? 1 : 0 }
  #=> [0, 0, 1, 1]

将
c
（两元素数组）的每个元素传递到块中。1。但是，更清楚的是，分解（或“消除歧义”）这些数组，并将它们所包含的两个单词中的每一个指定给块变量2：

传入的第一个元素是
[“hello”，“helio”]
，所以

aw => "hello"
bw #=> "helio"

我们执行

anagram?("hello", "helio") ? 1 : 0
  #=> 0

counts['l'] = counts['l'] + 1
  #=>    1 + 1
  #=> 2

这是

if anagram?("hello", "helio")
  1
else
  0
end
  #=> 0

counts['h'] = counts['h'] + 1

字谜？
方法

现在让我们继续看
字谜？
，带

aw = "hello"
bw = "helio"

自

我们不回来了

计算第一个单词中字母的频率

现在让我写下下面几行的
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}

（最后一行只是显示散列的值。）

在第一行中，我们创建一个默认值为零的hash
counts
。这意味着如果
counts
不包含键
k
，
counts[k]
将返回默认值非常重要：这样做不会更改哈希！三,

4将
“hello”
的每个字符传递到块中，并将其分配给块变量
c
。最初，
c='h'
和
h={}
。然后我们执行

counts['h'] += 1

这是

if anagram?("hello", "helio")
  1
else
  0
end
  #=> 0

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'
时，我们执行

anagram?("hello", "helio") ? 1 : 0
  #=> 0

counts['l'] = counts['l'] + 1
  #=>    1 + 1
  #=> 2

然后我们就结束了

counts #=> {"h"=>1, "e"=>1, "l"=>2, "o"=>1}

该方法将成为好朋友

此方法仅用于节省一些步骤。它允许我们写：

counts = Hash.new(0)
aw_down.each_char { |c| counts[c] += 1 }

作为

我们也可以摆脱这条线

aw_down = aw.downcase 

通过写作

counts = aw.downcase.each_char.with_object(Hash.new(0)) { |c,h| h[c] += 1 }

这似乎是一个小小的节省，但在许多其他情况下，使用
每个带有对象的\u
和其他
可枚举的
类方法可以链接方法，这是非常有用的

减少第二个单词中字母的字母计数

回忆

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'
被传递到块中。由于
计数['h']#=>1
，我们执行
计数['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

（即，返回默认值零，并且我们不想将
计数['i']
设置为
-1
），因此我们返回
false
，得出以下结论：
counts #=> {"h"=>0, "e"=>1, "l"=>2, "o"=>1}`.

counts #=> {"h"=>0, "e"=>0, "l"=>1, "o"=>1}

counts['i'] #=> 0

counts #=> {"h"=>0, "e"=>0, "l"=>0, "o"=>0}

enum = c.map
  #=> #<Enumerator: [["hello", "helio"], ["goodbye", "godbye"],
  #                  ["pants", "Spant"], ["baa", "aba"]]:map>

enum.to_a
  #=> [["hello", "helio"], ["goodbye", "godbye"],
  #    ["pants", "Spant"], ["baa", "aba"]]

enum.each { |aw,bw| anagram?(aw,bw) ? 1 : 0 }
  #=> [0, 0, 1, 1]

h = Hash.new('pig')
h['dog'] = 7 #=> 7
h            #=> {"dog"=>7}
h[0]         #=> "pig"
h['cat']     #=> "pig"
h[{:a=>1}]   #=> "pig"
h            #=> {"dog"=>7}

a.zip(b).map { |aw,bw| anagram?(aw,bw) }

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

0
0
1
1