从Ruby数组中获取出现2次或更多次的项

假设我有一个Ruby数组

[1,2,3,4,4,5,6,6,7,7]

我想找到出现2次或更多次的值

[4,6,7]

---

首先确定哪些项目只出现一次，然后删除这些项目，这将有助于我的流程。因此，我想通过首先查找出现一次的项来解决这个问题。

可能有更好的方法，但这是一种：

> [1,2,3,4,4,5,6,6,7,7].group_by{|i| i}.reject{|k,v| v.size == 1}.keys
=> [4, 6, 7]

细分：

> a = [1,2,3,4,4,5,6,6,7,7]
=> [1, 2, 3, 4, 4, 5, 6, 6, 7, 7]
> a1 = a.group_by{|i| i}
=> {1=>[1], 2=>[2], 3=>[3], 4=>[4, 4], 5=>[5], 6=>[6, 6], 7=>[7, 7]}
> a2 = a1.reject{|k,v| v.size == 1}
=> {4=>[4, 4], 6=>[6, 6], 7=>[7, 7]}
> a2.keys
=> [4, 6, 7]

---

也许有更好的方法，但这是一种：

> [1,2,3,4,4,5,6,6,7,7].group_by{|i| i}.reject{|k,v| v.size == 1}.keys
=> [4, 6, 7]

细分：

> a = [1,2,3,4,4,5,6,6,7,7]
=> [1, 2, 3, 4, 4, 5, 6, 6, 7, 7]
> a1 = a.group_by{|i| i}
=> {1=>[1], 2=>[2], 3=>[3], 4=>[4, 4], 5=>[5], 6=>[6, 6], 7=>[7, 7]}
> a2 = a1.reject{|k,v| v.size == 1}
=> {4=>[4, 4], 6=>[6, 6], 7=>[7, 7]}
> a2.keys
=> [4, 6, 7]

可以使用返回大于1的元素：

2.1.2 :005 > arr = [1,2,3,4,4,5,6,6,7,7]
 => [1, 2, 3, 4, 4, 5, 6, 6, 7, 7]
2.1.2 :006 > arr.select { |e| arr.count(e) > 1 }.uniq
 => [4, 6, 7]

希望这有助于您返回大于1的元素：

2.1.2 :005 > arr = [1,2,3,4,4,5,6,6,7,7]
 => [1, 2, 3, 4, 4, 5, 6, 6, 7, 7]
2.1.2 :006 > arr.select { |e| arr.count(e) > 1 }.uniq
 => [4, 6, 7]

---

希望这有助于

每个人都喜欢一条真正难以遵循的路线：

[1,2,3,4,4,5,6,6,7,7].each_with_object(Hash.new(0)) { |o, h| h[o] += 1 }.select { |_, v| v > 1 }.keys

添加一些空白和一些注释

[1,2,3,4,4,5,6,6,7,7].each_with_object(Hash.new(0)) { |o, h| 
  h[o] += 1 
}.select { |_, v| 
  v > 1 
}.keys

枚举并将我们的备忘录哈希传递给每个迭代，哈希默认为任何键都有0 对象的增量计数器 仅选择值大于1的键值对 抓住钥匙

---

这看起来与Phillip简洁的回答非常相似-理论上，这应该使用更少的内存，因为它不必构建中间数组来执行计数

每个人都喜欢一个非常难以遵循的线性：

[1,2,3,4,4,5,6,6,7,7].each_with_object(Hash.new(0)) { |o, h| h[o] += 1 }.select { |_, v| v > 1 }.keys

添加一些空白和一些注释

[1,2,3,4,4,5,6,6,7,7].each_with_object(Hash.new(0)) { |o, h| 
  h[o] += 1 
}.select { |_, v| 
  v > 1 
}.keys

枚举并将我们的备忘录哈希传递给每个迭代，哈希默认为任何键都有0 对象的增量计数器 仅选择值大于1的键值对 抓住钥匙 这看起来与Phillip简洁的回答非常相似-理论上，这应该使用更少的内存，因为它不必构建中间数组来执行计数

另一种方法：

a = [1,2,3,4,4,5,6,6,7,7]
au = a.uniq
a.reject { |i| au.delete(i) }
  #=> [4, 6, 7]

如果效率很重要，您可以使用一组：

require 'set'

s = Set.new
a.reject { |e| s.add?(e) }
  #=> [4, 6, 7]

另一种方式：

a = [1,2,3,4,4,5,6,6,7,7]
au = a.uniq
a.reject { |i| au.delete(i) }
  #=> [4, 6, 7]

如果效率很重要，您可以使用一组：

require 'set'

s = Set.new
a.reject { |e| s.add?(e) }
  #=> [4, 6, 7]

---

---

投票通过。这是迄今为止最好的答案。@sawa这个答案有什么更好的地方？我接受的那个似乎更简单。我不想粗鲁，我真的很想知道。看看我对这个答案的评论。@RyanBurnette基本上你接受的原始答案是非常低效的。对于大型阵列，当一个问题让我学到一些我甚至没有想到的东西时，它会开始变得非常缓慢。这件事我知道很重要，但我已经养成了不去想的习惯。在重新考虑了故障后，我确实看到了效率，这在我的用例中产生了巨大的差异。再次感谢，投票通过了。这是迄今为止最好的答案。@sawa这个答案有什么更好的地方？我接受的那个似乎更简单。我不想粗鲁，我真的很想知道。看看我对这个答案的评论。@RyanBurnette基本上你接受的原始答案是非常低效的。对于大型阵列，当一个问题让我学到一些我甚至没有想到的东西时，它会开始变得非常缓慢。这件事我知道很重要，但我已经养成了不去想的习惯。在重新考虑了故障后，我确实看到了效率，这在我的用例中产生了巨大的差异。再次感谢。这至少在^2上。这至少在^2上。您已将一个有效的答案标记为已接受，但其性能可能非常差。我谦恭地请求你再次审查答案，并接受一个表现出更好算法设计的答案。我只是问另一位评论者为什么我接受的答案不更好。我能理解。算法设计，不太重要。在我看来，算法设计比性能更重要。寻找最佳性能的微观优化很少是合适的，而编写在数据集大小加倍时不会突然接管机器的代码是非常非常重要的。我是一个相当实用的程序员，但老实说，自从我接受早期教育以来，我就一直在思考这个问题。只有当我遇到性能问题时，我才会考虑算法的设计。我打算改变这一切。这是我今天要读的书，但还有更多。再次感谢你的评论。我想再告诉你一个有趣的消息。这个问题背后的原因实际上涉及到我在Rails中所做的一些范围界定。并非贬低ptierno的响应，但当该方法被转换为作用域时，需要15秒才能得到响应。我在最后的代码中使用了Paul的答案，我在不到100毫秒的时间内得到了回应。您已经标记为接受了一个有效的答案，但这可能会带来糟糕的性能。我谦恭地请求你再次审查答案，并接受一个表现出更好算法设计的答案。我只是问另一位评论者为什么我接受的答案不更好。我能理解。算法设计，不太重要。在我看来，算法设计比性能更重要。寻找最佳性能的微观优化很少是合适的，而编写在数据集大小加倍时不会突然接管机器的代码是非常非常重要的

---

她从兔子洞里钻了出来。我是一个相当实用的程序员，但老实说，自从我接受早期教育以来，我就一直在思考这个问题。只有当我遇到性能问题时，我才会考虑算法的设计。我打算改变这一切。这是我今天要读的书，但还有更多。再次感谢你的评论。我想再告诉你一个有趣的消息。这个问题背后的原因实际上涉及到我在Rails中所做的一些范围界定。并非贬低ptierno的响应，但当该方法被转换为作用域时，需要15秒才能得到响应。我用Paul的答案作为我的最终代码，我在不到100毫秒的时间内得到了回复。我刚才还在考虑解决方案中的内存问题。很高兴有人贴出来了，很好。我刚才还在考虑解决方案中的内存问题。很高兴有人贴了。