반응형
루비에서 배열을 내림차순으로 정렬하는 방법
해시 배열이 있습니다.
[
{ :foo => 'foo', :bar => 2 },
{ :foo => 'foo', :bar => 3 },
{ :foo => 'foo', :bar => 5 },
]
는 이 을 이배을다값음따에합정니의 .:bar매 해시마다
는 사용중을 하고 있습니다.sort_by배열 위에서 정렬:
a.sort_by { |h| h[:bar] }
그러나 이렇게 하면 배열이 오름차순으로 정렬됩니다.내림차순으로 정렬하려면 어떻게 해야 합니까?
한 가지 해결책은 다음과 같습니다.
a.sort_by { |h| -h[:bar] }
하지만 그 부정적인 징후는 적절하지 않은 것 같습니다.
제안된 다양한 답변에 대한 벤치마크를 수행하는 것은 항상 유익합니다.제가 알아낸 것은 다음과 같습니다.
#!/usr/빈/빈
를 필요로 합니다.
아리 = []1000배 {arry << {:bar => 랜드(1000)}}
n = 500Benchmark.bm (20) do |x|x.report(") {n.times { arary.syslog{ |a,b| b[:bar] <=> a[:bar] } } }x.report ("역방향으로") {n.times { arary.times{ |a,b| a[:bar] <=> b[:bar] }.times }x.report{\colon_by[:bar]]) {n.times{arary.colon_by{|a| -a[:bar] }} }}x.report(report)_bya[:bar]*-1") {n.times {arary.vilen_by{|a|a[:bar]*-1}}} }x.report("\"_by.") {n.times {arary.dll_by{ |a| a[:bar] }.vmx }}끝.
사용자 시스템 전체 실제정렬 3.960000 0.010000 3.970000 (3.990886)역순 정렬 4.040000 0.0000 4.040000 (4.038849)sort_by -a[:bar] 0.690000 0.0000 0.6900 (0.692080)sort_by a[:bar]*-10.700000 0.000000 0.700000(0.699735)sort_by.dll! 0.65000000 0.650000(0.65447)
저는 @Pablo's가 흥미롭다고 생각합니다.sort_by{...}.reverse!가장 빠릅니다.테스트를 실행하기 전에는 "보다 느릴 것이라고 생각했습니다.-a[:bar]그러나 값을 부정하는 것은 전체 어레이를 한 번에 뒤집는 것보다 시간이 더 오래 걸립니다.큰 차이는 없지만 속도를 높이는 것이 도움이 됩니다.
이러한 결과는 Ruby 1.9에서 다르다는 것을 유의하시기 바랍니다.
다음은 Ruby 1.9.3p194(2012-04-20 개정판 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)
이것들은 오래된 맥북 프로에 있습니다.최신 컴퓨터 또는 더 빠른 컴퓨터의 값은 낮아지지만 상대적인 차이는 그대로 유지됩니다.
다음은 최신 하드웨어와 2.1.1 버전의 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)
최신 Macbook Pro에서 Ruby 2.2.1을 사용하여 위 코드를 실행하는 새로운 결과입니다.다시 말하지만, 정확한 숫자는 중요하지 않습니다. 그것은 그들의 관계입니다.
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)
2015년 중반 맥북 프로에서 Ruby 2.7.1용으로 업데이트됨:
Running Ruby 2.7.1
n=500
user system total real
sort 0.494707 0.003662 0.498369 ( 0.501064)
sort reverse 0.480181 0.005186 0.485367 ( 0.487972)
sort_by -a[:bar] 0.121521 0.003781 0.125302 ( 0.126557)
sort_by a[:bar]*-1 0.115097 0.003931 0.119028 ( 0.122991)
sort_by.reverse 0.110459 0.003414 0.113873 ( 0.114443)
sort_by.reverse! 0.108997 0.001631 0.110628 ( 0.111532)
...역방향 메소드는 실제로 역방향 배열을 반환하지 않습니다. 끝에서 시작하여 역방향으로 작동하는 열거자를 반환합니다.
소스는 다음과 같습니다.
static VALUE
rb_ary_reverse_m(VALUE ary)
{
long len = RARRAY_LEN(ary);
VALUE dup = rb_ary_new2(len);
if (len > 0) {
const VALUE *p1 = RARRAY_CONST_PTR_TRANSIENT(ary);
VALUE *p2 = (VALUE *)RARRAY_CONST_PTR_TRANSIENT(dup) + len - 1;
do *p2-- = *p1++; while (--len > 0);
}
ARY_SET_LEN(dup, RARRAY_LEN(ary));
return dup;
}
do *p2-- = *p1++; while (--len > 0);C를 올바르게 기억하면 포인터를 역순으로 요소에 복사하므로 배열이 역순으로 복사됩니다.
간단한 것으로, 그것은 내림차순의 의도를 나타냅니다.
descending = -1
a.sort_by { |h| h[:bar] * descending }
(그 동안 더 나은 방법을 생각해 보겠습니다) ;)
a.sort_by { |h| h[:bar] }.reverse!
할 수 있는 일:
a.sort{|a,b| b[:bar] <=> a[:bar]}
(다른 것 외에도) 기본적으로 두 가지 옵션이 있습니다.
a.sort_by { |h| -h[:bar] }
그리고.
a.sort_by { |h| h[:bar] }.reverse
정렬 키가 고유할 때 두 가지 방법 모두 동일한 결과를 제공하지만,reverseway는 동일한 키의 순서를 반대로 합니다.
예:
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}]
여러분은 종종 이것에 대해 신경 쓸 필요가 없지만, 가끔은 신경 쓸 필요가 있습니다.이러한 동작을 방지하려면 두 번째 정렬 키를 사용할 수 있습니다(같은 정렬 키를 가진 모든 항목에 대해 고유해야 함).
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}]
다음은 어떻습니까?
a.sort {|x,y| y[:bar]<=>x[:bar]}
효과가 있습니다!
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"}]
앞서 언급한 벤치마크 제품군과 관련하여 이러한 결과는 정렬된 어레이에도 적용됩니다.
sort_by/reverse다음과 같습니다.
# 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
결과:
$: 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)
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
결과:
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
오름차순에서 내림차순으로 또는 그 반대로 단순 솔루션은 다음과 같습니다.
줄들
str = ['ravi', 'aravind', 'joker', 'poker']
asc_string = str.sort # => ["aravind", "joker", "poker", "ravi"]
asc_string.reverse # => ["ravi", "poker", "joker", "aravind"]
숫자
digit = [234,45,1,5,78,45,34,9]
asc_digit = digit.sort # => [1, 5, 9, 34, 45, 45, 78, 234]
asc_digit.reverse # => [234, 78, 45, 45, 34, 9, 5, 1]
언급URL : https://stackoverflow.com/questions/2642182/how-to-sort-an-array-in-descending-order-in-ruby
반응형
'programing' 카테고리의 다른 글
| typescript와 함께 localStorage.getItem() 사용 (0) | 2023.07.01 |
|---|---|
| 파이썬 3에서 인코딩 선언을 사용해야 합니까? (0) | 2023.07.01 |
| C에서 부호 없는 int와 부호 없는 int의 차이 (0) | 2023.07.01 |
| 이 구조 Vuex에서 실행 중인 약속을 사용할 수 있는 방법이 있습니까? (0) | 2023.07.01 |
| 파이어베이스로 여러 소셜 서비스로 로그인하려면 어떻게 해야 합니까? (0) | 2023.06.26 |