#ruby koans

Just finished Ruby Koans.  I feel like it was a little bit advanced for me as a complete noob, but I still learned plenty about basic syntax and things like that.  Unfortunately, I ended up looking for help on most of the difficult challenges, but I still think even that helped me pick up a bit about the functionality of Ruby.  It didn't take too long to breeze through it, so I highly suggest Ruby Koans to someone that already knows other programming languages and is interested in picking up Ruby.  I would also slightly suggest it to a programming newb as a kind of head-first introduction to get your feet wet. [Does that last statement even make any sense? head=> feet?]  The structure of Koans is pretty interesting in that you can try to read through all of the code and solve the Koans through your own reasoning and logic, or you can paste all of the code into an irb and it will spit the answer back at you, so that is the reason why both newbs and advanced programmers can learn from it.

I'm starting to learn Ruby with Ruby Koans.  The structure is loosely based on Buddhism/the path to enlightenment.  Basically they want to plant the seeds of Ruby in your mind and have you meditate over them until you are "enlightened" with a keener sense of programming.  It's pretty neat because in each lesson, you start with a failed code.  Your first job is to correct the code, so that it's functional, then your final task is to "meditate" until you've come up with a better code (which can mean shorter, more explicit, more functional...)

So far Ruby Koans looks pretty crude to my untrained eye.  I downloaded it, and it's a program that's run in bash with associated .rb files to edit.  I think it should be good for me though, since I just finished an intro to shell.

So, I wrote this method this weekend as a part of Ruby Koans. It does what it's supposed to do, but I know there MUST be a better way. This is repetitive as shit, and it bothers me.

Thoughts, peanut gallery?

"Score" rules:

# * A set of three ones is 1000 points

# * A set of three numbers (other than ones) is worth 100 times the

#   number. (e.g. three fives is 500 points).

# * A one (that is not part of a set of three) is worth 100 points.

# * A five (that is not part of a set of three) is worth 50 points.

# * Everything else is worth 0 points.

# Examples:

# score([1,1,1,5,1]) => 1150 points

# score([2,3,4,6,2]) => 0 points

# score([3,4,5,3,3]) => 350 points

# score([1,5,1,2,4]) => 250 points

My code: 

def score(dice)

final_score = 0

ones = dice.select { |item| (item == 1) }

twos = dice.select { |item| (item == 2) }

threes = dice.select { |item| (item == 3) }

fours = dice.select { |item| (item == 4) }

fives = dice.select { |item| (item == 5) }

sixes = dice.select { |item| (item == 6) }

if ones.length >= 3

  final_score += (1000 + (ones.length%3 * 100))

else 

  final_score += (100 * ones.length)

end

if fives.length >= 3

  final_score += (500 + (fives.length%3 * 50))

else

  final_score += fives.length*50

end

if twos.length >= 3 

  final_score += 200

end

if threes.length >= 3

  final_score += 300

end

if fours.length >= 3

  final_score += 400

end

if sixes.length >= 3

  final_score += 600

end

return final_score

DRY in programming stands for "Don't Repeat Yourself". I tried to follow that principle in the design of my solution to the "Scoring Project", a.k.a. the Greed Game from the Neo Ruby Koans.

Being familiar with JavaScript and Python, I've noticed that the way Ruby deals with slicing is a bit different than what I am used to. In Ruby, there are actually four ways to use the "slice" method of string objects.  The syntax is as follows: word[parameter]

The parameter can be a fixnum, two fixnums separated by a comma, a range, a regexp with or without fixnum, or another string to search for. 

I find it interesting because while Ruby, Python, and JavaScript all have a similar syntax and similar methods for slicing strings, Ruby is the odd duck out with all it's options for how to do the same thing. Yukihiro Matsumoto (Matz) has said that, "Ruby inherited the Perl philosophy of having more than one way to do the same thing."

This seems like a good example of that philosophy in action.

I'm working from home again today, reading up on Ruby and working on my program little by little when clarity comes. 

The following is a guest post by Stephen Chen and originally appeared on his blog. Stephen is currently a student a The Flatiron School. You can learn more about him here, or follow him on twitter here.

One of the greatest parts of programming is learning something that blows your mind, a moment where this happens. It’s one of those moments that you realize you are a programming n00b, and that there is always a better way to do things. I had one of these moments recently when I was going through the Ruby Koans. In one of the introductory tests that cover strings you are told to think about string concatenation, and in particular which method is faster when building strings: “+” or ”<<".

The great part about leading questions like that is that you pretty much already know what the answer is going to be. So I went ahead and proved it, just so I could write this blog post. Awesome. There’s a really handy Benchmark class in Ruby that lets you time to execution of blocks of code, so I used that to scientifically prove what we all now know is true: ”<<" is faster than "+".

Here are the results: