查找陣列具有相同屬性的

Question

既然我有兩個屬性，一個數組對象集

my_arr = [{n_parents: 10, class: 'right'}, {n_parents: 10, class: 'right'}, {n_parents: 5, class: 'left'}, {n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}] 

我想獲得與對象的數組分享這兩個屬性中的大部分。所以在前面的例子：

result = [{n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}] 

因爲是共享n_parents = 2，並class = 'center'三個對象。

到目前爲止，我知道如何根據dos兩個屬性進行分組，但之後我不確定如何獲取具有更多元素的集合。

現在我有：

my_arr.group_by { |x| [x[:n_parents], x[:class]] } 

Answer 1

這應該爲你工作。這組散列由散列本身，然後由陣列得到最大的組數像下面

my_arr = [{n_parents: 10, class: 'right'}, {n_parents: 10, class: 'right'}, {n_parents: 5, class: 'left'}, {n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}] 
my_arr.group_by { |h| h }.max_by { |h,v| v.count }.last 
#=>[{:n_parents=>2, :class=>"center"}, {:n_parents=>2, :class=>"center"}, {:n_parents=>2, :class=>"center"}] 

Answer 2

東西：

my_arr.group_by(&:values).max_by { |_,v| v.size }.last 
# => [{:n_parents=>2, :class=>"center"}, 
#  {:n_parents=>2, :class=>"center"}, 
#  {:n_parents=>2, :class=>"center"}] 

Answer 3

我使用由OP使用的代碼和擴展了，要得到結果他想： -

my_arr.group_by { |x| [x[:n_parents], x[:class]] }.max_by{|k,v| v.size}.last 

輸出

#=> [{:n_parents=>2, :class=>"center"}, {:n_parents=>2, :class=>"center"}, {:n_parents=>2, :class=>"center"}] 

Answer 4

這是要發佈的第四個答案。前三個答案全部採用group_by/max_by/last。當然，這可能是最好的方法，但它是最有趣，最有趣的嗎？以下是其他一些方法來生成所需的結果。當

my_arr = [{n_parents: 10, class: 'right' }, {n_parents: 10, class: 'right' }, 
      {n_parents: 5, class: 'left' }, {n_parents: 2, class: 'center'}, 
      {n_parents: 2, class: 'center'}, {n_parents: 2, class: 'center'}] 

期望的結果是：

#=> [{:n_parents=>2, :class=>"center"}, 
    # {:n_parents=>2, :class=>"center"}, 
    # {:n_parents=>2, :class=>"center"}] 

＃1

# Create a hash `g` whose keys are the elements of `my_arr` (hashes) 
# and whose values are counts for the elements of `my_arr`. 
# `max_by` the values (counts) and construct the array. 

el, nbr = my_arr.each_with_object({}) { |h,g| g[h] = (g[h] ||= 0) + 1 } 
       .max_by { |_,v| v } 
arr = [el]*nbr 

＃2

# Sequentially delete the elements equal to the first element of `arr`, 
# each time calculating the number of elements deleted, by determining 
# `arr.size` before and after the deletion. Compare that number with the 
# largest number deleted so far to find the element with the maximum 
# number of instances in `arr`, then construct the array. 

arr = my_arr.map(&:dup) 
most_plentiful = { nbr_copies: 0, element: [] } 
until arr.empty? do 
    sz = arr.size 
    element = arr.delete(arr.first) 
    if sz - arr.size > most_plentiful[:nbr_copies] 
    most_plentiful = { nbr_copies: sz - arr.size, element: element } 
    end 
end 
arr = [most_plentiful[:element]]* most_plentiful[:nbr_copies]