Comments on: Ruby TMTOWTDI, Episode 1

By: zdk

zdk — Thu, 26 Jun 2008 16:23:01 +0000

h = Hash.new;str.each(’ ‘) { |s| h[s[0,1]] = s[1,3].to_i }

just wondering what about this?

By: David Koontz

David Koontz — Thu, 05 Jun 2008 16:23:01 +0000

My (without looking) solution was pretty similar to Nick’s although I didn’t assume the key would always be a single character.

str.split.inject({}) {|hash, item| item =~ /(\w+?)(\d+)/; hash[$1] = $2.to_i; hash}

Something strange I noticed was the parentheses around two of the block parameters in Nick’s solution. I removed them and to my surprise it had a drastic impact on performance.

With parentheses: 6.66 Without parentheses: 8.45

I got similar result with JRuby. Can anyone explain what the presence of parentheses in the argument list even does and how that might be impacting performance?

By: Pat Nakajima

Pat Nakajima — Thu, 05 Jun 2008 16:23:01 +0000

Great post! I look forward to more of these.

By: NicolÃ¡s Sanguinetti

NicolÃ¡s Sanguinetti — Thu, 05 Jun 2008 16:23:01 +0000

@David: The parentheses are there to unpack the second item into (k, v) instead of having to split it inside, I didn’t know it would give an improvement on performance.

@Andrew: Michel’s “quickest version” (the one posted in the first comment) run in 4.98 seconds in my machine, one of the new penryn MacBook Pros (2.4GHz Core 2 Duo, 2GB @667 stock)

By: Andrew Bennett

Andrew Bennett — Wed, 04 Jun 2008 16:23:01 +0000

Whoops, I hadn’t read all of the comments yet when I submitted my post. I thought NicolÃ¡s said that Martin’s was 4.98 seconds.

I went ahead tested some of the faster implementations to see who came out winner on my two systems.

The first system is a AMD Athlon XP 2400+ with 2.5GB of RAM running “Linux 2.6.24-17-generic i686″ (Ubuntu 8.04)

Andrew: 13.26
Armin #1: 11.45
Armin #2: 15.56
John: 8.81
Luke: 30.18
NicolÃ¡s: 14.09
Martin: 19.71
Michel: 10.33
Ryan: 52.45

The second system is an Intel Xeon 5130 @ 2.00GHz with 2GB of RAM running “FreeBSD 7.0-RELEASE amd64″

Andrew: 4.17
Armin #1: 4.98
Armin #2: 5.43
John: 3.86
Luke: 9.88
NicolÃ¡s: 5.60
Martin: 7.62
Michel: 4.01
Ryan: 21.33

For some reason, Armin’s first implementation is faster than mine on 32-bit Linux, while mine is faster than his on 64-bit FreeBSD.

John’s implementation still mops the floor with the rest of us.

By: Ryan

Ryan — Tue, 03 Jun 2008 16:23:01 +0000

Here’s one more:

s.split.sort.inject({}) { |h, a| h.merge(a[/^[a-z]/] => a[/[0-9]+$/].to_i) }

I could be wrong, but I don’t think “a20″.toi results in 20. I believe, if the number is first, doing a toi on a string will return the number. But when the letter is first, that’s not the case, which means that there still needs to be some sort of parsing, rather than a v.to_i implementation, right?

Again, maybe I’m wrong about that.

By: David Madden

David Madden — Tue, 03 Jun 2008 16:14:20 +0000

A great post, I love these as its always a good way to pick up tips.

This is especially interesting looking into the dark art of creating hashes using blocks.

By: john

john — Tue, 03 Jun 2008 16:14:20 +0000

I suppose these things are system dependeent. I tried the supplied methods and all were clocking in around the 25-30 seconds mark (Yes, I have a slow machine).

Applying a little KISS to the idea I came up with the very simple:

output = Hash.new
inter = Array.new
inter = str.split

inter.each do |s|
output[s[0,1]] = s[1,3].to_i
end

Which clocked in around 12 secs on my machine. It seems that forcing the types might help the compiler instead of making it choose.

Interesting test though.

By: Michael Boutros

Michael Boutros — Mon, 02 Jun 2008 23:08:08 +0000

This is what I’d do, takes less than 0.1 seconds using your benchmark code:

hash = {}; str.split.each {|str| hash.merge!({str[0, 1] => str[1, 2].to_i})}

By: Michel

Michel — Mon, 02 Jun 2008 23:07:27 +0000

The fastest approach I’ve found so far:

hash = Hash.new; str.scan(/(\w)(\d\d)/).each { |k, v| hash[k] = v.to_i }