Return to Answer

To guarantee ascending order in both columns we can compare by column when there is no nil and by max value when there is:

.sort { |(a0, a1), (b0, b1)|
  a0, a1, b0, b1 = [a0, a1, b0, b1].map(&:to_i)

  if ![a0, b0].include?(0)
    a0 <=> b0
  elsif ![a1, b1].include?(0)
    a1 <=> b1
  else
    [[a0, a1].max, a0, a1] <=> [[b0, b1].max, b0, b1]
  end
}

1. Compare two items at a time
2. Convert all the nils to something we can work with (.to_i makes them zero).
3. If the left columns are both positive integers then use that to sort.

• this works because if they both have numbers then the right number is always correct relative to the left, so sorting on the left gets you the right result.

4. If the right columns are both positive integers then use that to sort.

• we know it's not a matched pair and both left numbers are nil and both rights are comparable so...

5. Otherwise, create arrays to sort, with the 1st element of each array being the non-null (non-zero at this point) number. .max is just an easy way of getting the non-zero one.

To guarantee ascending order in both columns we can compare by column when there is no nil and by max value when there is:

.sort { |(a0, a1), (b0, b1)|
  if [a0, b0].none?(&:nil?)
    a0 <=> b0
  elsif [a1, b1].none?(&:nil?)
    a1 <=> b1
  else
    a0, a1, b0, b1 = [a0, a1, b0, b1].map(&:to_i)
    [[a0, a1].max, a0, a1] <=> [[b0, b1].max, b0, b1]
  end
}

1. Compare two items at a time
2. If the left columns are both positive integers then use that to sort.

• this works because if they both have numbers then the right number is always correct relative to the left, so sorting on the left gets you the right result.

3. If the right columns are both positive integers then use that to sort.

• we know it's not a matched pair and both left numbers are nil and both rights are comparable so...

4. Convert all the nils to something we can work with (.to_i makes them zero).
5. Otherwise, create arrays to sort, with the 1st element of each array being the non-null (non-zero at this point) number. .max is just an easy way of getting the non-zero one.

To guarantee ascending order in both columns we can compare by column when there is no nil and by max value when there is:

.sort { |(a0, a1), (b0, b1)|
  a0, a1, b0, b1 = [a0, a1, b0, b1].map(&:to_i)

  if ![a0, b0].include?(0)
    a0 <=> b0
  elsif ![a1, b1].include?(0)
    a1 <=> b1
  else
    [[a0, a1].max, a0, a1] <=> [[b0, b1].max, b0, b1]
  end
}

To guarantee ascending order in both columns we can compare by column when there is no nil and by max value when there is:

.sort { |(a0, a1), (b0, b1)|
  a0, a1, b0, b1 = [a0, a1, b0, b1].map(&:to_i)

  if ![a0, b0].include?(0)
    a0 <=> b0
  elsif ![a1, b1].include?(0)
    a1 <=> b1
  else
    [[a0, a1].max, a0, a1] <=> [[b0, b1].max, b0, b1]
  end
}

1. Compare two items at a time
2. Convert all the nils to something we can work with (.to_i makes them zero).
3. If the left columns are both positive integers then use that to sort.

• this works because if they both have numbers then the right number is always correct relative to the left, so sorting on the left gets you the right result.

4. If the right columns are both positive integers then use that to sort.

• we know it's not a matched pair and both left numbers are nil and both rights are comparable so...

5. Otherwise, create arrays to sort, with the 1st element of each array being the non-null (non-zero at this point) number. .max is just an easy way of getting the non-zero one.

Edited:

src.sort_by { |_0, _1| _0i, _1i = [_0, _1].map(&:to_i); [[_0, _1].include?(nil) ? [_0i, _1i].max : [_0i, _1i].min, _0i, _1i] }
=> [[nil, 1], [1, 2], [2, nil], [nil, 3], [3, nil], [nil, 4], [4, nil], [nil, 5], [5, nil], [nil, 6], [6, 8], [nil, 7], [7, 9], [8, nil], [9, 10]]

The trick is to use min when both are Numeric, max when there's a nil

To guarantee ascending order in both columns we can compare by column when there is no nil and by max value when there is:

.sort { |(a0, a1), (b0, b1)|
  a0, a1, b0, b1 = [a0, a1, b0, b1].map(&:to_i) 

  if ![a0, b0].include?(0) 
    a0 <=> b0
  elsif ![a1, b1].include?(0)
    a1 <=> b1
  else
    [[a0, a1].max, a0, a1] <=> [[b0, b1].max, b0, b1]
  end
}