8

我有两个数组，每个数组都包含任意数量的具有相同键但值不同的散列：

ArrayA = [{value: "abcd", value_length: 4, type: 0},{value: "abcdefgh", value_length: 8, type: 1}]
ArrayB = [{value: "ab", value_length: 2, type: 0},{value: "abc", value_length: 3, type: 1}]

尽管有任何数字，但散列的数量总是相等的。

我怎样才能找到:value_length每个哈希值是某种类型的最大值？

例如，:value_lengtha:type为 0 的散列的最大值:value_length为 4。a:type为 1 的散列的最大值为 8。

我只是无法解决这个问题。

4

4 回答 4

13

一个简单的方法：

all = ArrayA + ArrayB # Add them together if you want to search both arrays.
all.select{|x| x[:type] == 0}
   .max_by{|x| x[:value_length]}

如果你想重用它，只需创建一个函数：

def find_max_of_my_array(arr,type)
  arr.select{|x| x[:type] == type}
     .max_by{|x| x[:value_length]}
end

p find_max_of_my_array(ArrayA, 0) # => {:value=>"abcd", :value_length=>4, :type=>0}
于 2013-10-08T20:32:42.030 回答
0

我不完全确定我知道你想要什么输出，但试试这个。我假设数组是有序的，ArrayA[x][:type] == ArrayB[x][:type]并且您正在寻找(ArrayA[x], ArrayB[x])不是整个数组之间的最大值。如果不是这种情况，那么首先连接两个数组的其他解决方案会很好用。

filtered_by_type = ArrayA.zip(ArrayB).select{|x| x[0][:type] == type }
filtered_by_type.map {|a| a.max_by {|x| x[:value_length] } }
于 2013-10-08T20:36:48.580 回答
0

我是这样处理的：你正在寻找最大的东西，所以这个Array#max方法可能会很有用。你想要的是实际值本身，而不是包含的哈希值，这给了我们一些灵活性。熟悉函数式编程风格会有所帮助。在我看来，我可以看到select、map和是如何max结合在一起的。这是我的解决方案，如指定的那样，返回数字本身，即最大值：

def largest_value_length(type, hashes)  
  # Taking it slowly
  right_type_hashes = hashes.select{|h| h[:type] == type}                                                 
  value_lengths     = right_type_hashes.map{|h| h[:value_length]}                                         
  maximum           = value_lengths.max                                                                   

  # Or, in one line                                                     
  #hashes.select{|h| h[:type] == type}.map{|h| h[:value_length]}.max                                       
end                                                                                                       

puts largest_value_length(1, ArrayA + ArrayB)                                                             

=> 8
于 2013-10-08T20:56:57.927 回答
0

您也可以在按类型过滤后进行排序。这样你就可以得到最小的，第二大的等等。

all = ArrayA + ArrayB

all = all.select { |element| element[:type] == 1 }
        .sort_by { |k| k[:value_length] }.reverse

puts all[0][:value_length]
#8

puts all[all.length-1][:value_length]
#3
于 2016-03-29T00:35:41.647 回答