Yesterday was a big day. I graduated from the FlatironSchool 12-week program (yay! applause).

It’s been an intense race to pack in as much knowledge as possible in a short time-frame. As a parting gift, we were given an appropriate signifier that we are now versatile web application developers: a swiss army knife.

In recent weeks, it’s been difficult not to notice time ticking away against our task list:
– Absorb knowledge
– Complete web application for ScienceFair
– Absorb knowledge
– Practice ruby problems in preparation for Interviews
– Absorb knowledge
– Ask for 11th-hour lectures to make sure we understand topic xyz
– Absorb knowledge

In the end, as a coping mechanism, my peers and I decided that it was best to look at graduation not as the end of the road but as a new beginning. I’m happy to say that I’ve made it through the program. I’m also happy to report that I’ve largely absorbed most of my newfound knowledge.

The harrowing schedule has made it difficult for many of us to keep up with our blogs, but I’m ready and raring to go. So, I’ve decided to start a new segment called ‘Ruby & Me’ to a) force me to review my notes, b) test my understanding of basic concepts, and c) document my thought process as I work through problems. The immediate result may not be pretty, but this is what the result looks like short of refactoring. In the words of our Dean, Avi Flombaum: Make it work – Make it right – Make it fast. Then and only then: refactor.

Problem: Convert roman numerals to arabic

I’ve learned the hard way that it’s paralyzing to look too far ahead. Small successes are productive and feel great. So, I start with the following pseudo-code:

# Convert roman numerals to arabic:
# I, V, X, L, C, D, M
# NumTranslator.new("V") return arabic numeral value 5

My first goal is to create a class in which I can instantiate a new object and successfully pass my roman numeral between methods. By the way, I’ve also learned the hard way that too much coding without testing is a recipe for disaster. The last thing I want is to get bogged down debugging my code, but I’ve done it before… a lot. So, let’s see how this works out:

class NumTranslator
  def initialize(roman_numeral)
    @numeral = roman_numeral
  end

  def translator
    @numeral = "V" 
  end
end
puts NumTranslator.new("V").translator

return value #=> V

My first test passes. Awesome! Now I want to setup a simple translator that deals with all single-digit roman numerals:

def translator
    case @numeral
    when "I" then 1
    when "V" then 5
    when "X" then 10
    when "L" then 50
    when "C" then 100
    when "D" then 500
    when "M" then 1000
    else
    puts "Please enter a roman numeral"
  end 
end
puts NumTranslator.new("V").translator

return value #=> 5

Second test passes. Cool. Now I want to make sure that my full translation table works so I modify my call to accept user input:

puts "Enter roman numeral to convert to arabic numeral: "
print NumTranslator.new(gets.chomp).translator

At this point I realize that I should probably help guard my entries from my lightning fingers.

def initialize(roman_numeral)
  @numeral = roman_numeral.upcase
end

Sweet, now I can mistakenly enter a lowercase letter and it will automatically be upcased.

Now comes the tough part. Translation is easy at a single digit level, but if I enter a multiple digit roman numeral, I get the following response: “Please enter a roman numeral”. It’s time to alter my method so that I can deal with multiple letter roman numerals. I know that adjacent numerals sum to a total value e.g. “III” = 3. I also know that there are exceptions but I choose to ignore those for now.

Since each digit within a roman numeral translates to a value, I decide to update my translator method to split the input string and see if I can get “III” to return 3. I decide to use the collect method because I want to add each letter to an array. This will allow me to iterate through and add up all the values.

def translator
  @numeral = @numeral.split('').collect do |letter|
    case letter
    when "I" then 1
    when "V" then 5
    when "X" then 10
    when "L" then 50
    when "C" then 100
    when "D" then 500
    when "M" then 1000
    else
      puts "Please enter a roman numeral"
    end
  end
  @numeral.inject(:+)
end

(...)

gets.chomp #=> "III"
return value #=> 3

Excellent! It works. It’s time to get happy:

gets.chomp #=> "XI"
return value #=> 11

Yippee!

gets.chomp #=> "LV"
return value #=> 55

Hoorah!

gets.chomp #=> "XX"
return value #=> 20

Woopdeedoo!

gets.chomp #=> "IV"
return value #=> 6

Sigh. Ok, enough prolonging the inevitable. Good thing I’ve learned to manipulate my expectations: Yay! Yay! Yay! Waaaah!

Time for more pseudo-code:

# Translator method assumes each single-digit character is unique
# It splits and translates each character into a number, and adds it to an array
# Exceptions must be converted to a single-digit string and added back to the roman numeral
# Exceptions: "IV" = "4" / "IX" = "9" / "XL" = "F" (forty) / "XC" = "N" (ninety)

The translator method is already crazy long, so it seems appropriate to create a separate method to detect exceptions. I decide to start with “IV” and “IX” to keep things simple.

def detect_exception
  if @numeral.include?("IV")
    @numeral = @numeral.split("IV").push("4").inject(:+)
  elsif @numeral.include?("IX")
    @numeral = @numeral.split("IX").push("9").inject(:+)
  else
    @numeral
  end
end

Let’s test this real quick:

puts "Enter roman numeral to convert to arabic numeral: "
print NumTranslator.new(gets.chomp).detect_exception

gets.chomp #=> "XXIV"
return value #=> "XX4"

Cool, that works.

puts "Enter roman numeral to convert to arabic numeral: "
print NumTranslator.new(gets.chomp).detect_exception

gets.chomp #=> "LXIX"
return value #=> "LX9"

Awesome. Now I need to figure out how to expand this to include the other exceptions. I find that I can’t just add these as additional elsif statements because there seems to be confusion with overlapping numerals, so I try to nest them:

def detect_exception
    if @numeral.include?("IV")
      @numeral = @numeral.split("IV").push("4").inject(:+)
      if @numeral.include?("XL")
      @numeral = @numeral.split("XL").push("F").inject(:+)
      elsif @numeral.include?("XC")
      @numeral = @numeral.split("XC").push("N").inject(:+)
      else
      @numeral
      end
    elsif @numeral.include?("IX")
      @numeral = @numeral.split("IX").push("9").inject(:+)
      if @numeral.include?("XL")
      @numeral = @numeral.split("XL").push("F").inject(:+)
      elsif @numeral.include?("XC")
      @numeral = @numeral.split("XC").push("N").inject(:+)
      else
      @numeral
      end
    elsif @numeral.include?("XL")
      @numeral = @numeral.split("XL").push("F").inject(:+)
      elsif @numeral.include?("XC")
      @numeral = @numeral.split("XC").push("N").inject(:+)
    else
      @numeral
    end
  end

It’s butt ugly, but it works. Only a single line needs to be added to the translator method to call this new method to detect exceptions:

def translator
  @numeral = self.detect_exception
  @numeral = @numeral.split('').collect do |letter|
  (...)
  end
end

Excellent. Now we just need to test that everything works:

puts "Enter roman numeral to convert to arabic numeral: "
print NumTranslator.new(gets.chomp).translator

gets.chomp #=> "MMMDXCLXIX"
return value #=> "3669"

I can hardly contain myself. I run about fifteen different number combinations to make sure that everything works. Sweet! Hopefully, I didn’t leave out any exceptions.

UPDATE: Special thanks to Ed for pointing out a problem with my nested conditions under detect_exception, and for suggesting saving on real estate by using a hashmap instead of a case statement.

Here’s the final code:

class NumTranslator

  def initialize(roman_numeral)
    @numeral = roman_numeral.upcase
  end

  def detect_exception
    if @numeral.include?("IV")
      @numeral = @numeral.split("IV").push("4").inject(:+)
      if @numeral.include?("XL")
      @numeral = @numeral.split("XL").push("F").inject(:+)
      elsif @numeral.include?("XC")
      @numeral = @numeral.split("XC").push("N").inject(:+)
      else
      @numeral
      end
    elsif @numeral.include?("IX")
      @numeral = @numeral.split("IX").push("9").inject(:+)
      if @numeral.include?("XL")
      @numeral = @numeral.split("XL").push("F").inject(:+)
      elsif @numeral.include?("XC")
      @numeral = @numeral.split("XC").push("N").inject(:+)
      else
      @numeral
      end
    elsif @numeral.include?("XL")
      @numeral = @numeral.split("XL").push("F").inject(:+)
      elsif @numeral.include?("XC")
      @numeral = @numeral.split("XC").push("N").inject(:+)
    else
      @numeral
    end
  end

  def translator
    hashmap = {"I"=>1,"4"=>4,"V"=>5,"9"=>9,"X"=>10,"F"=>40,"L"=>50,"N"=>90,"C"=>100,"D"=>500,"M"=>1000}
    @numeral = self.detect_exception
    @numeral = @numeral.split('').collect do |numeral|
      hashmap[numeral]
    end
    @numeral.inject(:+)  
  end
end
puts "Enter roman numeral to convert to arabic numeral: "
puts NumTranslator.new(gets.chomp).translator