descending - ruby sort array by attribute

Ordenar una matriz en orden descendente en Ruby

Question

Tengo una serie de hashes como siguiente

[
{ :foo => ''foo'', :bar => 2 },
{ :foo => ''foo'', :bar => 3 },
{ :foo => ''foo'', :bar => 5 },
]

Estoy tratando de ordenar la matriz anterior en orden descendente de acuerdo con el valor de :bar en cada hash.

Estoy usando sort_by como siguiente para ordenar la matriz anterior.

a.sort_by { |h| h[:bar] }

Sin embargo, lo anterior ordena la matriz en orden ascendente. ¿Cómo lo hago ordenar en orden descendente?

Una solución fue hacer lo siguiente:

a.sort_by { |h| -h[:bar] }

Pero ese signo negativo no parece apropiado. ¿Alguna opinión?

Answer 1

Para aquellas personas que les gusta medir la velocidad en IPS;)

require ''benchmark/ips''
ary = []
1000.times {
ary << {:bar => rand(1000)}
}
Benchmark.ips do |x|
x.report("sort") { ary.sort{ |a,b| b[:bar] <=> a[:bar] } }
x.report("sort reverse") { ary.sort{ |a,b| a[:bar] <=> b[:bar] }.reverse }
x.report("sort_by -a[:bar]") { ary.sort_by{ |a| -a[:bar] } }
x.report("sort_by a[:bar]*-1") { ary.sort_by{ |a| a[:bar]*-1 } }
x.report("sort_by.reverse!") { ary.sort_by{ |a| a[:bar] }.reverse }
x.compare!
end

Y resultados:

Warming up --------------------------------------
sort 93.000 i/100ms
sort reverse 91.000 i/100ms
sort_by -a[:bar] 382.000 i/100ms
sort_by a[:bar]*-1 398.000 i/100ms
sort_by.reverse! 397.000 i/100ms
Calculating -------------------------------------
sort 938.530 (± 1.8%) i/s - 4.743k in 5.055290s
sort reverse 901.157 (± 6.1%) i/s - 4.550k in 5.075351s
sort_by -a[:bar] 3.814k (± 4.4%) i/s - 19.100k in 5.019260s
sort_by a[:bar]*-1 3.732k (± 4.3%) i/s - 18.706k in 5.021720s
sort_by.reverse! 3.928k (± 3.6%) i/s - 19.850k in 5.060202s
Comparison:
sort_by.reverse!: 3927.8 i/s
sort_by -a[:bar]: 3813.9 i/s - same-ish: difference falls within error
sort_by a[:bar]*-1: 3732.3 i/s - same-ish: difference falls within error
sort: 938.5 i/s - 4.19x slower
sort reverse: 901.2 i/s - 4.36x slower

Answer 2

Podrías hacerlo:

a.sort{|a,b| b[:bar] <=> a[:bar]}

Answer 3

Qué pasa:

 a.sort {|x,y| y[:bar]<=>x[:bar]}

¡¡Funciona!!

irb
>> a = [
?> { :foo => ''foo'', :bar => 2 },
?> { :foo => ''foo'', :bar => 3 },
?> { :foo => ''foo'', :bar => 5 },
?> ]
=> [{:bar=>2, :foo=>"foo"}, {:bar=>3, :foo=>"foo"}, {:bar=>5, :foo=>"foo"}]
>> a.sort {|x,y| y[:bar]<=>x[:bar]}
=> [{:bar=>5, :foo=>"foo"}, {:bar=>3, :foo=>"foo"}, {:bar=>2, :foo=>"foo"}]

Answer 4

Respecto a la suite de referencia mencionada ... estos resultados también son válidos para arreglos ordenados. sort_by / reverse is :)

P.ej:

# foo.rb
require ''benchmark''
NUM_RUNS = 1000
# arr = []
arr1 = 3000.times.map { { num: rand(1000) } }
arr2 = 3000.times.map { |n| { num: n } }.reverse
Benchmark.bm(20) do |x|
{ ''randomized'' => arr1,
''sorted'' => arr2 }.each do |label, arr|
puts ''---------------------------------------------------''
puts label
x.report(''sort_by / reverse'') {
NUM_RUNS.times { arr.sort_by { |h| h[:num] }.reverse }
}
x.report(''sort_by -'') {
NUM_RUNS.times { arr.sort_by { |h| -h[:num] } }
}
end
end

Y los resultados:

$: ruby foo.rb
user system total real
---------------------------------------------------
randomized
sort_by / reverse 1.680000 0.010000 1.690000 ( 1.682051)
sort_by - 1.830000 0.000000 1.830000 ( 1.830359)
---------------------------------------------------
sorted
sort_by / reverse 0.400000 0.000000 0.400000 ( 0.402990)
sort_by - 0.500000 0.000000 0.500000 ( 0.499350)

Answer 5

Siempre es esclarecedor hacer un punto de referencia en las diversas respuestas sugeridas. Esto es lo que descubrí:

#!/usr/bin/ruby require ''benchmark'' ary = [] 1000.times { ary << {:bar => rand(1000)} } n = 500 Benchmark.bm(20) do |x| x.report("sort") { n.times { ary.sort{ |a,b| b[:bar] <=> a[:bar] } } } x.report("sort reverse") { n.times { ary.sort{ |a,b| a[:bar] <=> b[:bar] }.reverse } } x.report("sort_by -a[:bar]") { n.times { ary.sort_by{ |a| -a[:bar] } } } x.report("sort_by a[:bar]*-1") { n.times { ary.sort_by{ |a| a[:bar]*-1 } } } x.report("sort_by.reverse!") { n.times { ary.sort_by{ |a| a[:bar] }.reverse } } end user system total real sort 3.960000 0.010000 3.970000 ( 3.990886) sort reverse 4.040000 0.000000 4.040000 ( 4.038849) sort_by -a[:bar] 0.690000 0.000000 0.690000 ( 0.692080) sort_by a[:bar]*-1 0.700000 0.000000 0.700000 ( 0.699735) sort_by.reverse! 0.650000 0.000000 0.650000 ( 0.654447)

Creo que es interesante que @ la sort_by{...}.reverse! de Pablo sort_by{...}.reverse! es el más rápido Antes de ejecutar la prueba, pensé que sería más lento que " -a[:bar] ", pero negar el valor toma más tiempo que en invertir una matriz completa en una sola pasada. No hay mucha diferencia, pero cada pequeña aceleración ayuda.

Tenga en cuenta que estos resultados son diferentes en Ruby 1.9

Aquí están los resultados para Ruby 1.9.3p194 (2012-04-20 revisión 35410) [x86_64-darwin10.8.0]:

 user system total real
sort 1.340000 0.010000 1.350000 ( 1.346331)
sort reverse 1.300000 0.000000 1.300000 ( 1.310446)
sort_by -a[:bar] 0.430000 0.000000 0.430000 ( 0.429606)
sort_by a[:bar]*-1 0.420000 0.000000 0.420000 ( 0.414383)
sort_by.reverse! 0.400000 0.000000 0.400000 ( 0.401275)

Estos están en un viejo MacBook Pro. Las máquinas más nuevas o más rápidas tendrán valores más bajos, pero las diferencias relativas se mantendrán.

Aquí hay una versión actualizada del hardware más nuevo y la versión 2.1.1 de Ruby:

#!/usr/bin/ruby
require ''benchmark''
puts "Running Ruby #{RUBY_VERSION}"
ary = []
1000.times {
ary << {:bar => rand(1000)}
}
n = 500
puts "n=#{n}"
Benchmark.bm(20) do |x|
x.report("sort") { n.times { ary.dup.sort{ |a,b| b[:bar] <=> a[:bar] } } }
x.report("sort reverse") { n.times { ary.dup.sort{ |a,b| a[:bar] <=> b[:bar] }.reverse } }
x.report("sort_by -a[:bar]") { n.times { ary.dup.sort_by{ |a| -a[:bar] } } }
x.report("sort_by a[:bar]*-1") { n.times { ary.dup.sort_by{ |a| a[:bar]*-1 } } }
x.report("sort_by.reverse") { n.times { ary.dup.sort_by{ |a| a[:bar] }.reverse } }
x.report("sort_by.reverse!") { n.times { ary.dup.sort_by{ |a| a[:bar] }.reverse! } }
end
# >> Running Ruby 2.1.1
# >> n=500
# >> user system total real
# >> sort 0.670000 0.000000 0.670000 ( 0.667754)
# >> sort reverse 0.650000 0.000000 0.650000 ( 0.655582)
# >> sort_by -a[:bar] 0.260000 0.010000 0.270000 ( 0.255919)
# >> sort_by a[:bar]*-1 0.250000 0.000000 0.250000 ( 0.258924)
# >> sort_by.reverse 0.250000 0.000000 0.250000 ( 0.245179)
# >> sort_by.reverse! 0.240000 0.000000 0.240000 ( 0.242340)

Nuevos resultados ejecutando el código anterior usando Ruby 2.2.1 en una Macbook Pro más reciente. Una vez más, los números exactos no son importantes, son sus relaciones:

Running Ruby 2.2.1
n=500
user system total real
sort 0.650000 0.000000 0.650000 ( 0.653191)
sort reverse 0.650000 0.000000 0.650000 ( 0.648761)
sort_by -a[:bar] 0.240000 0.010000 0.250000 ( 0.245193)
sort_by a[:bar]*-1 0.240000 0.000000 0.240000 ( 0.240541)
sort_by.reverse 0.230000 0.000000 0.230000 ( 0.228571)
sort_by.reverse! 0.230000 0.000000 0.230000 ( 0.230040)

Answer 6

Solo una cosa rápida, que denota la intención del orden descendente.

descending = -1
a.sort_by { |h| h[:bar] * descending }

(Pensará de una manera mejor en el tiempo);)

a.sort_by { |h| h[:bar] }.reverse!

Answer 7

Veo que tenemos (al lado de otras) básicamente dos opciones:

a.sort_by { |h| -h[:bar] }

y

a.sort_by { |h| h[:bar] }.reverse

Si bien ambas formas le dan el mismo resultado cuando su clave de clasificación es única, tenga en cuenta que la reverse invertirá el orden de las claves que son iguales .

Ejemplo:

a = [{foo: 1, bar: 1},{foo: 2,bar: 1}]
a.sort_by {|h| -h[:bar]}
=> [{:foo=>1, :bar=>1}, {:foo=>2, :bar=>1}]
a.sort_by {|h| h[:bar]}.reverse
=> [{:foo=>2, :bar=>1}, {:foo=>1, :bar=>1}]

Mientras que a menudo no necesitas preocuparte por esto, a veces lo haces. Para evitar tal comportamiento, puede introducir una segunda clave de clasificación (que seguramente debe ser única al menos para todos los elementos que tienen la misma clave de clasificación):

a.sort_by {|h| [-h[:bar],-h[:foo]]}
=> [{:foo=>2, :bar=>1}, {:foo=>1, :bar=>1}]
a.sort_by {|h| [h[:bar],h[:foo]]}.reverse
=> [{:foo=>2, :bar=>1}, {:foo=>1, :bar=>1}]