Sort an array and store the counters in another array in Ruby

Question

I'm currently sorting an array of arrays (of numbers) in Ruby with this code:

grapes_sorted = vintages_grapes.group_by(&:itself).sort_by do |k, v| -v.size end.map(&:first) 

It works very well. However, I want to store the counters corresponding to each sort in another array.

I tried:

grapes_sorted_counters = []
grapes_sorted = vintages_grapes.group_by(&:itself).sort_by do |k, v| 
                        -v.size 
                        grapes_sorted_counters << v.size 
                    end.map(&:first) 

It store the counters, however, the sort is broken, not ordered like it should be. I suppose v.size (and not -v.size) is the cause of the problem in the block.

How can I store the number of occurrences properly in grapes_sorted_counters[] ? Thanks.

Answer 1

I believe the problem with your code has been identified, so I will suggest an alternative approach.

grapes = %w|red blue red green yellow red blue blue green red|
  #> ["red", "blue", "red", "green", "yellow", "red", "blue",
  #   "blue", "green", "red"]

grapes.tally.sort_by { |_,count| -count }.map(&:first)
  #=> ["red", "blue", "green", "yellow"]

See Enumerable#tally.

The steps are as follows.

h = grapes.tally
  #=> {"red"=>4, "blue"=>3, "green"=>2, "yellow"=>1} 
a = h.sort_by { |_,count| -count }
  #=> [["red", 4], ["blue", 3], ["green", 2], ["yellow", 1]] 
a.map(&:first)
  #=> ["red", "blue", "green", "yellow"] 

Answer 2

it's this part that's messing you up:

sort_by do |k, v| 
  -v.size 
  grapes_sorted_counters << v.size 
end

You are trying to sort by -v.size. But the return value of the block is grapes_sorted_counters << v.size.

So just switch around the order of those lines.

Answer 3

I think you have a bug in your sorting anyway.

I'm currently sorting an array of arrays (of numbers) in Ruby with this code:

I assume the input value is something like this

vintages_grapes = [[3,2], [3,2,1], [3]]

So in the first step you do a group_by

vintages_grapes.group_by(&:itself)
# -> {[3, 2]=>[[3, 2]], [3, 2, 1]=>[[3, 2, 1]], [3]=>[[3]]}

You can see that the values are all nested in another array [] (they all have size 1).

sort_by do |key, value| 
  -value.size # size 1 for all values
end

The group_by shouldn't be necessary, you can just do

result = []
vintages_grapes.sort_by do |array| 
  result << array.size
  result.sort!
  -array.size
end

Answer 4

I'm curious what you think -v.size is doing. – the Tin Man 39 mins ago
It's sorting the counter by max value first.

That's not how sort or sort_by work. Both rely on the value returned by the block to indicate how to order the values.

This example is more like your code, where you try to negate the value of size but then return the array. This will result in an ascending sort:

foo = [1, 3, 2, 4]
foo.sort_by { |i| 
  -i
   i
 }
 # => [1, 2, 3, 4]

If you return the negated value to the block, then the results use a descending order:

 foo.sort_by { |i| 
  i
  -i
 }
 # => [4, 3, 2, 1]

Your code is doing this:

 bar = []
 foo.sort_by { |i|
  -i
  bar << i
}
# => [1, 3, 2, 4]

which results in bar having the original order as it was filled in the same order as they exist in foo, and then you pass that to map. And, assigning inside the sort block will always do that. You'd want to do it after that block has closed and Ruby has returned the ordered values.

All that said, sort_by is the wrong method to use, you should use sort instead. Why is explained in Ruby's sort_by documentation, so look there for more information.

Also, reversing the order is best done using the reverse method, not by negating the value. See "How to sort an array in descending order in Ruby".