多个索引阵列 - 红宝石

Question

我有一个游戏的项目，如果选择的字母在秘密单词中存在，则需要给选择的字母留下深刻的印象，但是当我试图捕获选择字母的索引时，例如“ A”，例如秘密单词“ programador，代码使我返回“ programador”一词的所有索引，不仅是字母“ a”存在的索引。

palavra_secreta = "programador"
letra_procurada = "a"
total_encontrado = palavra_secreta.count letra_procurada

palavra_secreta_array = palavra_secreta.split("")
puts palavra_secreta_array.each_with_index.select { |letra_procurada, index| 
  total_encontrado >= 1 
}.map { |pair| pair[1] }

此代码正在返回我：0 1 2 3 4 5 6 7 8 9 10 10

Answer 1

在您的代码中， total_encontrado 是 2 ，它大于或等于 1 。结果，您给出 #select 的条件始终是正确的，因此它选择了每个字符的索引。然后，您将其映射到索引。

相反，您可能只想选择匹配 letra_procurada 的字母。

palavra_secreta = "programador"
letra_procurada = "a"
total_encontrado = palavra_secreta.count letra_procurada

palavra_secreta_array = palavra_secreta.split("")
puts palavra_secreta_array
     .each_with_index
     .select { |letra, index| letra_procurada == letra }
     .map { |pair| pair[1] }

您也可以使用 #FILTER_MAP （Ruby 2.7及以后）来简化这一点。

palavra_secreta = "programador"
letra_procurada = "a"
total_encontrado = palavra_secreta.count letra_procurada

palavra_secreta_array = palavra_secreta.split("")
puts palavra_secreta_array
     .each_with_index
     .filter_map { |letra, index| index if letra_procurada == letra }

Answer 2

选择条款中的条件对于每个索引都是正确的，因为它仅检查 total_encontrado 变量，并且该值不会在每次迭代中更改。

puts palavra_secreta_array
  .each_with_index
  .select { |letra_procurada, index| total_encontrado >= 1 }
#                                    ^^^^^^^^^^^^^^^^^^^^^
  .map { |pair| pair[1] }

您想要的是选择匹配猜测字符的索引，因此您的条件可以做到这一点：

puts palavra_secreta_array
  .each_with_index
  .select { |letra, index| letra == letra_procurada }
  .map { |pair| pair[1] }

请注意，我必须将第一个参数的名称更改为 select block。您已经在那里重复使用 letra_procurada ，但这将具有 shadowing 实际 letra_procurada 变量。请记住，选择正在调用数组中每个元素的块，并且选择仅该块返回true的元素，因此块的第一个参数是元素从数组中，如果您阴影或忽略它，您将不知道在块内部处理什么。

您还可以将其缩小一点，然后跳过 split ，以使用 string＃enter_char ：

puts palavra_secrata
    .each_char
    .with_index
    .select { |c, _| c == letra_procurada }
    .map(&:last)

Answer 3

“ letra_procurada” 是指“字母想要”，因此您似乎必须印象 pass 您想要选择的元素：

letra_procurada = "a"

palavra_secreta_array.each_with_index.select { |letra_procurada, index| }
#                                               ^^^^^^^^^^^^^^^

但是这根本不是阻止参数或特别是选择的方式。如果您将 letra_procurada 用字符串字面替换，则您将获得 syntaxerror 右away：

palavra_secreta_array.each_with_index.select { |"a", index| }
# SyntaxError: unexpected string literal

一个块包含您传递块的方法，该方法将块传递到（这里：<代码>选择）可以调用（多次，一次或根本只有一次）。在每个块调用时， | letra_procurada，index | ）将从中传递 the方法（ie select> select> select ） 块。

您调用选择，但选择调用块。这也被称为“ “ noreferrer”> callback ”。

在您的示例中，选择调用每个元素的块，并将该元素作为块参数 letra_procurada 和 index 。然后，它希望该块返回 true 或 false 。该返回值确定该元素是否包含在结果中。

由于该块的第一个参数可以是任何字母，因此您可能需要一个更通用的变量名称。这样的事情：

palavra_secreta_array.each_with_index.select { |letra, index|
   # ...
}

一些例子可能有助于理解这一点。仅选择 奇数？<奇数？ /code> 索引：

palavra_secreta_array.each_with_index.select { |letra, index|
   index.odd?
}
#=> [["r", 1], ["g", 3], ["a", 5], ["a", 7], ["o", 9]]

仅选择字母等于“ R” 或等于等于的元素“ o” ：（ || 表示“或”）

palavra_secreta_array.each_with_index.select { |letra, index|
   letra == "r" || letra == "o"
}
#=> [["r", 1], ["o", 2], ["r", 4], ["o", 9], ["r", 10]]

或合并，仅选择“ R” 或“ o” 和一个奇数索引：（＆amp;＆amp;＆amp; 表示“ and”）

palavra_secreta_array.each_with_index.select { |letra, index|
  (letra == "r" || letra == "o") && index.odd?
}
#=> [["r", 1], ["o", 9]]

，您可以看到，使用块是一种非常灵活且强大的选择元素的方法。

回到你的问题。您当前的块仅检查 total_encontrado 是否更大或等于 1 。它不考虑当前字母或其索引。而且由于 total_encontrado 大于 1 ，因此block 始终返回 true 和<代码>选择返回所有元素。

要选择匹配通缉字母的字母 letra_procurada 的元素，您将使用：

palavra_secreta_array.each_with_index.select { |letra, index|
   letra == letra_procurada
}
#=> [["a", 5], ["a", 7]]

Answer 4

当处理相应元素满足特定条件的集合或字符串索引的问题时，要返回特定条件时，使用一系列索引 [0,1，..，n]通常很方便。例如，如果一个人想返回数字 arr = [3,2,6,5,4] 的元素的索引数组，则可能会写下以下一个< sup> 1 ：

arr.each_index.select  { |i| arr[i].odd? }
(0..arr.size-1).select { |i| arr[i].odd? }
arr.size.times.select  { |i| arr[i].odd? }

所有返回 [0，3] 。

对于涉及字符串的当前问题，我们可以使用上面的最后两种方法中的任何一种：

(0..palavra_secreta.size-1).select { |i| palavra_secreta[i] == letra_procurada }
palavra_secreta.size.times.select { |i| palavra_secreta[i] == letra_procurada }

两者都返回 [5，7] 。

我相信这种方法读得很好，因为读者应该立即明显地返回一系列索引。

^{1。我意识到，在＃2中，我本可以写（0 ... arr.size），但是我发现混合两个和三点范围往往会产生错误，所以我只使用三个 - 当无法使用两个点范围时，请范围。}