Question

提供以下ruby哈希：

{
    cat: {
        1: 2,
        2: 10,
        3: 11,
        4: 1
    },
    wings: {
        1: 3,
        2: 5,
        3: 7,
        4: 7
    },
    grimace: {
        1: 4,
        2: 5,
        3: 5,
        4: 1
    },
    stubborn: {
        1: 5,
        2: 3,
        3: 7,
        4: 5
    }
}

如何通过“leaf”除以“4”的总和对哈希进行排序，例如“cat”的比较值为（2 + 10 + 11）= 23，“翅膀”的值将为是（3 + 5 + 7）= 15因此，如果我只是比较那两个，他们将是正确的顺序，最高总和在顶部。

可以安全地假设它总是{1：value，2：value，3：value，4：value}，因为它们是我定义的常量的关键。

也可以安全地假设我只想排除键“4”，并始终使用键“1”，“2”和“3”

基于乔丹的建议，我得到了这个工作：

  tag_hash = tag_hash.sort_by do |h| 
    h[1].inject(0) do |sum, n| 
      n[0] == 4 ? sum : sum + (n[1] || 0)
    end
  end

结果看起来有点偏，但似乎是我的代码，一旦我确认我会接受答案，谢谢乔丹！

我已经更新了我的解决方案以使用Wayne Conrad的想法，看到我对他的答案的评论 - 它是否有可能在它排序时没有携带所有内容，我链接到我的评论中的图像，显示实际排序的结果以图表形式..对我来说似乎很奇怪..

Answer 1

tag_hash = tag_hash.sort_by do |_, leaf|
  leaf.reject do |key, _|
    key == 4
  end.collect(&:last).inject(:+)
end

Answer 2

my_hash.sort_by do |_, h|
  h.inject(0) do |sum, n|
    # only add to the sum if the key isn't '4'
    n[0] == 4 ? sum : (sum + n[1])
  end
end

当然，这可以缩短为一个难以理解的单线：

my_hash.sort_by {|k,h| h.inject(0) {|sum,n| n[0] == 4 ? sum : (sum + n[1]) } }

Answer 3

此

puts a.sort_by { |k, v| -v.values[0..-1].inject(&:+) }

产生以下输出，这是你想要的吗？

cat
{1=>2, 2=>10, 3=>11, 4=>1}
wings
{1=>3, 2=>5, 3=>7, 4=>7}
stubborn
{1=>5, 2=>3, 3=>7, 4=>5}
grimace
{1=>4, 2=>5, 3=>5, 4=>1}

Answer 4

这似乎有效：

x.sort_by{ |_,h| h.values.take(3).inject(:+) }

这假定子索引已排序（前三个条目是您要总结的条目）。

使用ActiveSupport时，您可以这样做：

x.sort_by{ |_,h| h.values.take(3).sum }

或

x.sort_by{ |_,h| h.slice(1,2,3).values.sum }

Hash＃slice返回仅包含传递给slice的键的哈希。 Array＃take返回一个包含源数组的前n个条目的数组。

（我认为需要Ruby 1.9.1）

在ruby中对嵌套哈希进行排序

4 个答案: