# Sorting decimal index numbers?

Hi there,
I’m working with a list of items that contain decimal-based index
numbers. I’m sorry I don’t know the term for these kinds of numbers, and
I’m having trouble finding out how to sort them properly. To wit:

1.1
1.10
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9

When the index numbers are float or strings, they sort like this. But I
want “1.10” to be the last number. Any idea how to put these guys in the
right order?

Thanks!
Aaron.

On Mar 27, 9:18 pm, Aaron V. [email protected] wrote:

When the index numbers are float or strings, they sort like this. But I
want “1.10” to be the last number. Any idea how to put these guys in the
right order?

``````\$ irb
>> nums = ['1.1', '1.2', '1.10', '1.9']
=> ["1.1", "1.2", "1.10", "1.9"]
>> nums.sort
=> ["1.1", "1.10", "1.2", "1.9"]
>> nums.collect { |n|  n.split('.').collect { |i|
``````

i.to_i } }.sort.collect { |n| n.join(’.’) }
=> [“1.1”, “1.2”, “1.9”, “1.10”]

Aaron V. [email protected] wrote:

1.5
1.6
1.7
1.8
1.9

When the index numbers are float or strings, they sort like this. But I
want “1.10” to be the last number. Any idea how to put these guys in the
right order?

These are not numbers; they’re strings. Or at least, they need to be; if
they weren’t, 1.1 and 1.10 would be indistinguishable. So let’s assume
they are strings. Then what you’re asking to do is to compare the two
halves of each string as an integer. Take 1.1 and 2.1, for instance;
they compare as 1 and 2 would compare as integers. Very well, now take
1.10 and 1.2, for instance. 1 and 1 are the same, so 10 and 2 need to
compare as the integers 10 and 2. So:

arr = %w{
1.1
1.10
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
}
arr = arr.sort do |x,y|
x1, x2 = x.split(".")
y1, y2 = y.split(".")
if x1 != y1
x1.to_i <=> y1.to_i
else
x2.to_i <=> y2.to_i
end
end
p arr

If there are a lot of these, however, it would be much better to do a
keyed sort using sort_by. How to create keys depends on what you know
about the data. If we knew for a fact that the second half was always
between 1 and 99, it would be easy:

arr = arr.sort_by do |x|
x1, x2 = x.split(".")
x1.to_i * 100 + x2.to_i
end

If the second half can be any length, though, you’ll have to determine
the maximum length first, and change that “100” multiplier accordingly.

m.

Hi Matt,
Are you the Matt N., of AppleScript fame? It’s a privilege to
have an answer from you!

matt neuburg wrote:

These are not numbers; they’re strings. Or at least, they need to be; if
they weren’t, 1.1 and 1.10 would be indistinguishable.

Yes, I think this was becoming my assumption. The head-scratcher for me
was trying to determine if this sort of numbering scheme (“the
hierarchical list”, if you will) was a special case in Ruby or
generally. But in my model right now (this is for a Rails project) it’s
set as a string.

If there are a lot of these, however, it would be much better to do a
keyed sort using sort_by. How to create keys depends on what you know
about the data. If we knew for a fact that the second half was always
between 1 and 99, it would be easy:

arr = arr.sort_by do |x|
x1, x2 = x.split(".")
x1.to_i * 100 + x2.to_i
end

And it turns out that a hundred is more than enough in this case. Thanks
to you, and to Yossef above, for a working solution.

Cheers!
Aaron.

Hi,

At Sat, 28 Mar 2009 13:04:43 +0900,
Matthias R. wrote in [ruby-talk:332318]:

If the second half can be any length, though, you’ll have to determine
the maximum length first, and change that “100” multiplier accordingly.

Either that or use arrays as sort keys:

arr = arr.sort_by do |x|
x.split(".").map {|i| i.to_i}
end

enc/depend file in 1.9 has more generic code.

alphanumeric_order = proc {|e| e.scan(/(\d+)|(\D+)/).map {|n,a|
a||[n.size,n.to_i]}.flatten}

But this fails if strings start with digit and strings start
with non-digit are mixed. In such case, this is safer.

alphanumeric_order = proc {|e|
e.scan(/(\A\D*|\G\D+)(\d+)/).map{|a,n|[a,n.size,n.to_i]}.flatten}

matt neuburg wrote:

If there are a lot of these, however, it would be much better to do a
keyed sort using sort_by. How to create keys depends on what you know
about the data. If we knew for a fact that the second half was always
between 1 and 99, it would be easy:

arr = arr.sort_by do |x|
x1, x2 = x.split(".")
x1.to_i * 100 + x2.to_i
end

If the second half can be any length, though, you’ll have to determine
the maximum length first, and change that “100” multiplier accordingly.

Either that or use arrays as sort keys:

arr = arr.sort_by do |x|
x.split(".").map {|i| i.to_i}
end

-Matthias

On 28.03.2009 05:04, Matthias R. wrote:

If the second half can be any length, though, you’ll have to determine
the maximum length first, and change that “100” multiplier accordingly.

Either that or use arrays as sort keys:

arr = arr.sort_by do |x|
x.split(".").map {|i| i.to_i}
end

Here’s a variant (1.9 only):

arr.sort_by {|x| x.scan(/\d+/).map(&:to_i)}

Cheers

robert

Matthias R. [email protected] wrote:

If the second half can be any length, though, you’ll have to determine
the maximum length first, and change that “100” multiplier accordingly.

Either that or use arrays as sort keys:

arr = arr.sort_by do |x|
x.split(".").map {|i| i.to_i}
end

Yes, that’s better; my first answer failed to take into account Array’s
existing implementation of the spaceship operator. m.

On Mar 27, 11:04 pm, Matthias R. [email protected] wrote:

arr = arr.sort_by do |x|
x.split(".").map {|i| i.to_i}
end

Durr, of course that’s better than my solution of transforming the
array elements and then re-creating the original ones after the sort.
For some reason, I completely forgot about sort_by.

Aaron V. [email protected] wrote:

I’m working with a list of items that contain decimal-based index
numbers. I’m sorry I don’t know the term for these kinds of numbers,
and I’m having trouble finding out how to sort them properly […]

Probably the Dewey Decimal Classification, or the Universal Decimal
Classification.

Chris