Sorting array of array in ruby

All earlier answers based on sort or sort_by are wrong, as they modify the order of non-nil values. Note, that the asker wants only the nil values to be sunk to the end of the array, while preserving the original order of all other elements.

Here's how it can be done correctly.

Short version

class Array
  def sink_nils!
    self.replace self.partition { |value| value[0] != nil }.flatten(1)
  end
end

arr.sink_nils!

This code converts arr into an array equal to the one requested by the asker.

Same code in a more readable form, explained

class Array
  def sink_nils!
    # Move nil-containing elements into a separate array
    result = self.partition { |value| value[0] != nil }

    # Glue two arrays into a single one
    result.flatten!(1)

    # Swap the original array with the result
    self.replace result
  end
end

arr.sink_nils!

Here's what happening.

• .partition splits the array into two arrays, based on the condition provided in a block. We use a value[0] != nil condition which separates nil-containing items from non-nil-containing ones, while preserving their original order.
• As .partition returns an array of arrays, we glue it back together using .flatten. We don't want to lose the hierarchy of inner arrays, so we request only one level of flattening: .flatten(1).
• The whole thing is declared as a method for the Array class, so that in can be conveniently used. As the method is destructive (it modifies the original array), we add an exclaimation mark to the end of its name: .sink_nils!.
• Finally, the method is applied on the existing array.

The sort_by block must return something that can always be compared. Adding the unless prevents it doing that (because the block has nothing else to return, and nil cannot be compared with a Fixnum)

Instead, you need a fallback result to use as a sort key when a is nil:

arr.sort_by{|a,b| a.nil? ? 999999999 : b[:length].to_i }