Ruby array sort without changing position of nils - arrays

Question

I am working with an array of arrays. I need to sort the rows, and the sort criteria is the value of each column (starting with the 2nd column) successively from left to right. Nil values must be pushed to the bottom. Once pushed to the bottom, I need to leave nil columns as they are without successive searches changing their position relative to each other. Starting with this array:
sort_array =
[[297, 100, 101, 235, 253, nil, nil, nil],
[286, 116, 116, 213, nil, nil, nil, nil],
[256, 105, 111, 212, 216, 264, nil, nil],
[276, 108, 111, 204, 207, 257, 259, 367],
[274, 66, 66, 120, 121, nil, 150, nil],
[298, 114, 117, 270, 270, nil, nil, nil],
[296, 127, 130, 259, 264, 324, 332, nil],
[283, 102, 106, 193, 199, 247, 248, 343]]
I iterate across the array with these lines of code:
(1..sort_array[0].size - 1).each do |i|
sort_array.sort_by! { |e| [e[i] ? 0 : 1, e[i]] }
end
The idea is to ignore the first column, but sort the second through nth column in ascending order pushing nil values to the bottom. This gives the following result:
=> [[283, 102, 106, 193, 199, 247, 248, 343],
[276, 108, 111, 204, 207, 257, 259, 367],
[256, 105, 111, 212, 216, 264, nil, nil],
[297, 100, 101, 235, 253, nil, nil, nil],
[296, 127, 130, 259, 264, 324, 332, nil],
[274, 66, 66, 120, 121, nil, 150, nil],
[298, 114, 117, 270, 270, nil, nil, nil],
[286, 116, 116, 213, nil, nil, nil, nil]]
This is close to what I need, but not quite right. The problem is that the nil values once pushed to the bottom don't stay put. For example, after sorting the column whose first value is 247, the array would have looked like this:
=> [[283, ... 247, ...]
[276, ... 257, ...]
[256, ... 264, ...]
[296, ... 324, ...]
[297, ... nil, ...]
[274, ... nil, ...]
[298, ... nil, ...]
[286, ... nil, ...]
But further sorting on columns to the right results in the nil values being reordered, which messes up the sort. Nil values need to stay put unless a cell to the right is non-nil, in which case it should be sorted as usual.
The table should look like this when the sort is finished:
=> [[283, 102, 106, 193, 199, 247, 248, 343],
[276, 108, 111, 204, 207, 257, 259, 367],
[274, 66, 66, 120, 121, nil, 150, nil],
[296, 127, 130, 259, 264, 324, 332, nil],
[256, 105, 111, 212, 216, 264, nil, nil],
[297, 100, 101, 235, 253, nil, nil, nil],
[298, 114, 117, 270, 270, nil, nil, nil],
[286, 116, 116, 213, nil, nil, nil, nil]]
Could someone please help me write a method that will achieve this result?
It may be helpful to see the real-life example of what I am trying to achieve. Here is a link to a spreadsheet:
https://github.com/SplitTime/OpenSplitTime/blob/master/hardrock2015test.xlsx
Each row is a runner effort. Runners are ranked by final finish time of course. But those who do not finish are ranked by how far they made it and what time they made it to their last waypoint.
Though the linked spreadsheet does not show it, the sort also needs to deal with nil values with time data to the right, representing times that didn't get recorded for whatever reason.

Answer 1

I think that you want to sort the rows by its 2nd to last elements in reverse order (with nil being treated as Infinity):
arrays = [[297, 100, 101, 235, 253, nil, nil, nil],
[286, 116, 116, 213, nil, nil, nil, nil],
[256, 105, 111, 212, 216, 264, nil, nil],
[276, 108, 111, 204, 207, 257, 259, 367],
[274, 66, 66, 120, 121, nil, 150, nil],
[298, 114, 117, 270, 270, nil, nil, nil],
[296, 127, 130, 259, 264, 324, 332, nil],
[283, 102, 106, 193, 199, 247, 248, 343]]
arrays.sort_by { |a| a[1..-1].reverse.map { |e| e || Float::INFINITY } }
#=> [[283, 102, 106, 193, 199, 247, 248, 343],
# [276, 108, 111, 204, 207, 257, 259, 367],
# [274, 66, 66, 120, 121, nil, 150, nil],
# [296, 127, 130, 259, 264, 324, 332, nil],
# [256, 105, 111, 212, 216, 264, nil, nil],
# [297, 100, 101, 235, 253, nil, nil, nil],
# [298, 114, 117, 270, 270, nil, nil, nil],
# [286, 116, 116, 213, nil, nil, nil, nil]]
At least, this produces the expected result.
Since the first row consists of keys, you could take advantage of Ruby's array decomposition abilities and use |_, *vs| vs.reverse... instead of |a| a[1..-1].reverse.... Here, _ refers to the (unused) key and *vs collects the remaining elements.