Ruby检查列表数组中的一个元素与同一数组中的另一个元素_Ruby_Arrays

Ruby检查列表数组中的一个元素与同一数组中的另一个元素

ruby arrays

Ruby检查列表数组中的一个元素与同一数组中的另一个元素,ruby,arrays,Ruby,Arrays,我相信这有一个简单的解决方案，但我一直在迭代一个单词数组，并将第一个单词（最终是它的长度）与列表中的每个单词进行比较，然后将第二个单词与所有单词和第三个单词进行比较，以此类推如果我有两个选择，我可以做这样的事情 word1 = "weird" word2 = "wired" if word1.chars.sort.length == word2.chars.sort.length true else false end ... weird wider wierd wired wri

我相信这有一个简单的解决方案，但我一直在迭代一个单词数组，并将第一个单词（最终是它的长度）与列表中的每个单词进行比较，然后将第二个单词与所有单词和第三个单词进行比较，以此类推

如果我有两个选择，我可以做这样的事情

word1 = "weird"
word2 = "wired"

if word1.chars.sort.length == word2.chars.sort.length
  true
else
  false
end

...
weird wider wierd wired wried
weirs wires wiser wries
welkin winkle
welkins winkles
welting winglet
weltings winglets
wenchers wrenches
wettish whitest
whale wheal

我开始很简单

编辑

有了这些单词，我会检查它们是否是字谜

我有一个包含数千个单词的文本文件。所以输出与此类似

There were 17346 anagram words found.
Would you like to list them? (Y/n)> Y
...
weird wider wierd wired wried
weirs wires wiser wries

编辑2

我想写一个程序，可以在单词列表中找到所有的字谜。例如，“沉默”和“倾听”这两个词就是字谜

假设一本字典里有很多字谜，但它们没有顺序，或相互关联，它们有相同的元素，但位置不同，程序会满足于从word.txt文件中读取并找到字谜单词，我会有找到的字谜数量，并选择显示我的发现。用这样的样品

word1 = "weird"
word2 = "wired"

if word1.chars.sort.length == word2.chars.sort.length
  true
else
  false
end

...
weird wider wierd wired wried
weirs wires wiser wries
welkin winkle
welkins winkles
welting winglet
weltings winglets
wenchers wrenches
wettish whitest
whale wheal

像这样的

文字=%q（贴边小翼，白色白色，挥舞宽…）

迭代将从贴边到小翼检查它们是否是字谜

如果是这样的话，可能会存储在一个新的数组或其他东西中。然后去检查一下，依此类推

我不完全清楚你想做什么，但是如果你需要看所有长度相同的单词，那么这可能会有帮助：

> words = %w[cat dog fish bird red blue green white pink]
=> ["cat", "dog", "fish", "bird", "red", "blue", "green", "white", "pink"]

> words.group_by{|e| e.length}
=> {3=>["cat", "dog", "red"], 
    4=>["fish", "bird", "blue", "pink"], 
    5=>["green", "white"]}

我不完全清楚你想做什么，但如果你需要看所有长度相同的单词，那么这可能会有帮助：

> words = %w[cat dog fish bird red blue green white pink]
=> ["cat", "dog", "fish", "bird", "red", "blue", "green", "white", "pink"]

> words.group_by{|e| e.length}
=> {3=>["cat", "dog", "red"], 
    4=>["fish", "bird", "blue", "pink"], 
    5=>["green", "white"]}

我同意Phillip的观点，现在还不清楚你到底在寻找什么，但这里有另一个关于你想做什么的猜测

reference_word = "12345"

my_array = %w(weird wired not_wierd not_wired)

my_array.select { |item| item.length == reference_word.length }
        .each { |matched_size| puts matched_size }

将

{| matched_size | put matched_size}

替换为与参考词大小匹配的项目所要做的任何事情

我同意Phillip的观点，不清楚您到底在寻找什么，但这里是另一个关于您试图做什么的猜测

reference_word = "12345"

my_array = %w(weird wired not_wierd not_wired)

my_array.select { |item| item.length == reference_word.length }
        .each { |matched_size| puts matched_size }

将

{| matched_size | put matched_size}

替换为与参考单词大小匹配的项目，如果数组是这样的：

words=[“wierd”、“wierd”、“wierd”、“vafasdfasd”]

您可以将第一个单词与下面的每个单词进行比较：

for i in 0...words.length
    if words[0] == words[i]
        puts true
    else
        puts false
    end
end

但要对数组中的每个单词重复此操作，需要使用嵌套循环。这可能行得通

for i in 0...words.length
    for j in i...words.length
        if words[i] == words[j]
            puts true
        else
            puts false
        end
    end
end

假设一个单词本身不是一个字谜：

for i in 0...words.length
    for j in i...words.length
        if words[i] == words[j]
            puts false
        elsif words[i].chars.sort == words[j].chars.sort
            puts true
        else
            puts false
        end
    end
end

顺便说一句，我认为上面的代码并不好。如果你在比较字谜很好，但是你可能在比较你可以有两倍的东西（但仍然不想把东西和它们自己比较）。我认为这是一个更好的解决方案：

for i in 0...(words.length-1)
    for j in i...(words.length-1)
        if words[i].chars.sort == words[j+1].chars.sort && words[i] != words[j+1]
            puts true
        else
            puts false
        end
    end
end

如果您的数组是这样的：

words=[“wierd”、“wired”、“wierd”、“vafasdfasd”]

您可以将第一个单词与下面的每个单词进行比较：

for i in 0...words.length
    if words[0] == words[i]
        puts true
    else
        puts false
    end
end

但要对数组中的每个单词重复此操作，需要使用嵌套循环。这可能行得通

for i in 0...words.length
    for j in i...words.length
        if words[i] == words[j]
            puts true
        else
            puts false
        end
    end
end

假设一个单词本身不是一个字谜：

for i in 0...words.length
    for j in i...words.length
        if words[i] == words[j]
            puts false
        elsif words[i].chars.sort == words[j].chars.sort
            puts true
        else
            puts false
        end
    end
end

for i in 0...(words.length-1)
    for j in i...(words.length-1)
        if words[i].chars.sort == words[j+1].chars.sort && words[i] != words[j+1]
            puts true
        else
            puts false
        end
    end
end

如果你想要所有的字谜，你可以

words.group_by{|w| w.split('').sort}.values

这将为您提供一个数组，其中每个数组都是列表中的所有单词，它们都是彼此的字谜。

如果您只需要所有字谜，您可以

words.group_by{|w| w.split('').sort}.values

这将为您提供一个数组，其中每个数组都是列表中的所有单词，它们都是彼此的拼音。

如果您的问题源于一种预感，即根据单词长度进行过滤可能会更快，您可以通过修改@SteveTurczyn的答案来实现：

words = %w{wierd a wired ow dew wierd vafasdfasd wed wo}
  #=> ["wierd", "a", "wired", "ow", "dew", "wierd", "vafasdfasd", "wed", "wo"] 

words.group_by { |w| w.length }.values.flat_map do |a|
  if (a.size > 1)
    a.group_by{|w| w.split('').sort}.values
  else
    [a]
  end
end
  #=> [["wierd", "wired", "wierd"], ["a"], ["ow", "wo"],
  #    ["dew", "wed"], ["vafasdfasd"]]

步骤如下：

h = words.group_by { |w| w.length }
  #=> {5=>["wierd", "wired", "wierd"], 1=>["a"], 2=>["ow", "wo"],
  #    3=>["dew", "wed"], 10=>["vafasdfasd"]} 
b = h.values
  #=> [["wierd", "wired", "wierd"], ["a"], ["ow", "wo"],
  #    ["dew", "wed"], ["vafasdfasd"]] 
b.flat_map do |a|
  if (a.size > 1)
    a.group_by{|w| w.split('').sort}.values
  else
    [a]
  end
end
  #=> [["wierd", "wired", "wierd"], ["a"], ["ow", "wo"],
  #    ["dew", "wed"], ["vafasdfasd"]]

的第一个元素通过

flat\u map

传递到上述块中，并分配给块变量

，是：

a = ["wierd", "wired", "wierd"]

因此，我们执行以下操作：

if (3 > 1)
  ["wierd", "wired", "wierd"].group_by{|w| w.split('').sort}.values
else
  [["wierd", "wired", "wierd"]]
end

因为

3>1

是

true

：

c = ["wierd", "wired", "wierd"].group_by { |w| w.split('').sort }
  #=> {["d", "e", "i", "r", "w"]=>["wierd", "wired", "wierd"]}
d = c.values
  #=> [["wierd", "wired", "wierd"]]

由于我们使用的是

flat_map

，而不是

map

，

被映射到数组

[“wierd”、“wired”、“wierd”]

的其他元素的处理方式也类似。

如果您的问题源于一种预感，即根据字长进行过滤可能会更快，您可以通过修改@SteveTurczyn的答案：

words = %w{wierd a wired ow dew wierd vafasdfasd wed wo}
  #=> ["wierd", "a", "wired", "ow", "dew", "wierd", "vafasdfasd", "wed", "wo"] 

words.group_by { |w| w.length }.values.flat_map do |a|
  if (a.size > 1)
    a.group_by{|w| w.split('').sort}.values
  else
    [a]
  end
end
  #=> [["wierd", "wired", "wierd"], ["a"], ["ow", "wo"],
  #    ["dew", "wed"], ["vafasdfasd"]]