Ruby 按布尔值和数字排序

Question

我使用的是 Ruby 1.8.7。我有以下哈希数组。我需要先按布尔值排序，但这些结果也必须按原始顺序排序。我基本上需要将所有真正的散列移到数组的顶部，但保持原来的顺序。

任何帮助将不胜感激！

array = [{:id => 1, :accepts => false}, 
         {:id => 2, :accepts => false}, 
         {:id => 3, :accepts => true}, 
         {:id => 4, :accepts => false}, 
         {:id => 5, :accepts => true}]

sorted = array.sort do |x, y|
  if x[:accepts] == y[:accepts]
    0
  elsif x[:accepts] == true
    -1
  elsif x[:accepts] == false
    1
  end
end

我得到的这种类型：

5 - 真
3 - 真
2 - 错误
4 - 错误
1 - 错误

我需要它来让步：

3 - 真
5 - 真
1 - 错误
2 - 错误
4 - 错误

Answer 1

array = [{:id => 1, :accepts => false}, 
         {:id => 2, :accepts => false}, 
         {:id => 3, :accepts => true}, 
         {:id => 4, :accepts => false}, 
         {:id => 5, :accepts => true}]

sorted = array.sort do |x, y|
  if x[:accepts] ^ y[:accepts]
      x[:accepts] ? -1 : 1
  else
      x[:id] <=> y[:id]
  end
end

puts sorted

如果您愿意，也可以使用!= 而不是^。

Answer 2

这样就可以了：

array.sort{|a,b| (a[:accepts] == b[:accepts]) ? ((a[:id] < b[:id]) ? -1 : 1) : (a[:accepts] ? -1 : 1)}

Answer 3

如果:accepts 相等，您可以在:id 键上添加额外检查，如下所示：

array = [{:id => 1, :accepts => false}, 
    {:id => 2, :accepts => false}, 
    {:id => 3, :accepts => true}, 
    {:id => 4, :accepts => false}, 
    {:id => 5, :accepts => true}]

sorted = array.sort do |x, y|
  if x[:accepts] == y[:accepts]
    if x[:id] == y[:id]
      0
    elsif x[:id] > y[:id]
      1
    elsif x[:id] < y[:id]
      -1
    end
  elsif x[:accepts] == true
    -1
  elsif x[:accepts] == false
    1
  end
end

Answer 4

a.sort_by { |x| (x[:accepts] ? 0 : 99999) + x[:id] }

更新：嗯，显然这需要x[:id].respond_to? "+"，另外还有相对于常量的范围限制。

然而，这是最短的，可能也是最快的答案，如果也显然是最有问题的。

真正重要的一课是它说明了人们应该超越Array（或其他）并检查Enumerable是否在(your object).class.ancestors中。这些问题及其观众通常在回答“接下来我应该了解 Ruby 什么，我怀疑还有其他方法”。

不管这是否是一种很好的排序方式（诚然这是有问题的），这个答案建议 #sort_by 并且只是 查找文档 为 #sort_by （它不在数组中）将教一个小但对初学者来说很重要。

Answer 5

对这些事情使用sort_by，而不是sort！

array.sort_by {|h| [h[:accepts] ? 0 : 1,h[:id]]}

Answer 6

这是因为 Ruby 1.8.7 中的排序不稳定

• http://redmine.ruby-lang.org/issues/show/1089
• http://en.wikipedia.org/wiki/Stable_sort#Stability

您需要做的就是让您的排序块不返回0：

sorted = array.sort do |x, y|
  if x[:accepts] == y[:accepts]
    x[:id] <=> y[:id]  # not 0
  elsif x[:accepts]
    -1
  else
    1
  end
end

（无需明确将布尔值与true 和false 进行比较）

Answer 7

好吧，从您的问题中，我推断您确实想按 :accepts 值对结果进行分组，并将两个结果集合并回一个数组。我对此的解决方案是：

array.select {|where| where[:accepts] } | array.reject {|where| where[:accepts] }
# => [{:accepts=>true, :id=>3},
#     {:accepts=>true, :id=>5},
#     {:accepts=>false, :id=>1},
#     {:accepts=>false, :id=>2},
#     {:accepts=>false, :id=>4}]

这将保持原始顺序，而不会在 :id 键上暗示任何排序。这意味着您不需要辅助键来保留顺序，并且无论传输的数据如何，您都可以保留结果的顺序。

这也可能有用（也许正是您进一步评估所需要的）：

array.group_by {|where| where[:accepts] }
# => {false=>[{:accepts=>false, :id=>1},
#             {:accepts=>false, :id=>2},
#             {:accepts=>false, :id=>4}],
#      true=>[{:accepts=>true, :id=>3},
#             {:accepts=>true, :id=>5}]}

同样，不涉及人工排序...group_by 是 1.8.7 中的新功能。

PS：如果您不希望第一个代码 sn-p 从数组中删除重复项，请将 bar 运算符替换为 plus 运算符。 “|”根据theory of sets（联合）合并两个集合，而“+”连接两个集合（结果不是真正的集合，而是一个普通数组）。