Ruby ordenar por booleano y el número

Question

Estoy usando Ruby 1.8.7. Tengo la siguiente matriz de hashes. Necesito ordenar primero el valor booleano, pero esos resultados también deben ordenarse en el orden original. Básicamente, necesito cambiar todos los hashes verdaderos a la parte superior de la matriz, pero mantener el orden original.

¡Cualquier ayuda sería apreciada!

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 

Este tipo que tengo rendimientos:

5 - true
3 - true
2 - falsa
4 - falsa
1 - false

lo necesito para producir :

3 - true
5 - tr ue
1 - false
2 - falsa
4 - falsa

Answer 1

Esto hace el trabajo:

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

Answer 2

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 

O != en lugar de ^, si lo desea.

Answer 3

Se podría añadir una comprobación adicional en la clave :id si :accepts es igual, de la siguiente manera:

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] } 

actualización: Bueno, Obviamente, esto requiere x[:id].respond_to? "+" y, además, hay restricciones en su rango en relación con las constantes.

Esta es, sin embargo, la respuesta más corta y probablemente la más rápida, si también obviamente la más cuestionable.

La lección realmente importante es que ilustra que uno debe mirar más allá de Array (o lo que sea) y marcar Enumerable si eso está en (your object).class.ancestors. Estas preguntas y sus lectores son a menudo después de una respuesta a "lo que debería aprender sobre Ruby siguiente, sospecho que hay otras maneras".

Independientemente de si esto es una buena manera de ordenar (la verdad es cuestionable) esta respuesta sugiere #sort_by y justo la búsqueda de los documentos para #sort_by (que no es en Array) va a enseñar una pequeña pero importante lección para un principiante.

Answer 5

Utilice sort_by para estas cosas, no sort!

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

Answer 6

Esto es porque la clasificación en Ruby 1.8.7 no es estable

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

Todo lo que necesita hacer es tener su bloque de tipo no vuelva 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 

(hay necesidad de comparar de forma explícita un valor lógico a true y false)

Answer 7

Bueno, de su pregunta deduzco que realmente quería agrupar los resultados por el valor :accepts y fusionar ambos conjuntos de resultados en una matriz. Mi solución a este hubiera sido:

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}] 

Esto mantendrá el orden original sin que ello implique ningún tipo en la tecla :id. Esto significa que no necesitará una clave auxiliar para conservar el pedido, y puede conservar el orden en el resultado independientemente de los datos transportados.

Esto también puede ser útil (y tal vez exactamente lo que necesita para evaluaciones adicionales):

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}]} 

Una vez más, no hay clases artificiales involucrados ... group_by es nuevo en 1.8.7.

PD: Si no desea que el primer fragmento de código elimine los duplicados de su matriz, reemplace el operador de la barra con el operador más. "|" fusiona dos conjuntos de acuerdo con theory of sets (unión) mientras que "+" concatena dos conjuntos (el resultado no es realmente un conjunto, sino un conjunto simple).