Roman Numerals (Python recipe) by Paul Winkler

ActiveState Code (http://code.activestate.com/recipes/81611/)

int_to_roman: another approach. The following is my first attempt at int_to_roman. In this version, my approach was simply to follow, as closely as I could, the plain english description of the rules given above. I rejected this version because it actually ends up being longer and more complex than the version given above. It turns out to be easier to just forcibly assign values to "IV" and its friends than it is to implement the rule that determines the values.

def int_to_roman(input):
   if type(input) != type(1):
      raise TypeError, "expected integer, got %s" % type(input)
   if not 0 < input < 4000:
      raise ValueError, "Argument must be between 1 and 3999"
   result = ""
   nums = ('M', 'D', 'C', 'L', 'X', 'V', 'I')
   ints = (1000, 500, 100, 50,  10,  5,   1)
   places = [0,] * len(nums)
   # count how many times each int we have
   for i in range(len(ints)):
      value = ints[i]
      count = input / value
      places[i] = count
      if count: input -= count * value
   # Format the output string
   for i in range(len(places)):
      if places[i] < 4:
         result += nums[i] * places[i]
      else:
         # 4 repetitions means we're trying to represent 4 or 9
         # of something.
         if places[i -1] == 0:
            # it's a 4.
            result += nums[i] + nums[i -1]
         else:
            # it's a 9.
            # 'the next' character is 2 away from here, not 1;
            # otherwise we'd get 'IV' when we want 'IX'.
            # We'll also need to delete the previous character,
            # or we'll get stuff like 'VIX' when we want 'IX'.
            result = result[:-1] + nums[i] + nums[i -2]
   return result

Alternative - roman.py with unit testing. See Mark Pilgrim's chapter on developing a roman numeral conversion module, with unit testing in his excellent Dive into Python book: http://diveintopython.org/roman_divein.html for another alternative.

A better roman_to_int... Thanks Graham (and Mark!). I checked out Mark's "Dive Into Python". Good stuff, and all free under the Python license.

His roman-to-int converter is much simpler than the one I posted above. However, Mark relies on a regexp to validate the input. That's fine, and makes the function nicely short; but it puts a lot of the logic in the regexp, which I feel is more likely to be misread than is a slightly longer function.

So here's my latest version. It's based on Mark's, except that I use an additional field in each tuple to enforce the maximum allowed repetitions of each numeral, and I rely on the ordering of the tuple to enforce the correct ordering of numerals. With that done, we don't need a regexp, nor do we need to test by calling int_to_roman(result) as my first version did.

def roman_to_int(input):
   """
   Convert a roman numeral to an integer.

   >>> r = range(1, 4000)
   >>> nums = [int_to_roman(i) for i in r]
   >>> ints = [roman_to_int(n) for n in nums]
   >>> print r == ints
   1

   >>> roman_to_int('VVVIV')
   Traceback (most recent call last):
    ...
   ValueError: input is not a valid roman numeral: VVVIV
   >>> roman_to_int(1)
   Traceback (most recent call last):
    ...
   TypeError: expected string, got
   >>> roman_to_int('a')
   Traceback (most recent call last):
    ...
   ValueError: input is not a valid roman numeral: A
   >>> roman_to_int('IL')
   Traceback (most recent call last):
    ...
   ValueError: input is not a valid roman numeral: IL
   """
   try:
      input = input.upper()
   except AttributeError:
      raise TypeError, 'expected string, got %s' % type(input)
   # map of (numeral, value, maxcount) tuples
   roman_numeral_map = (('M',  1000, 3), ('CM', 900, 1),
                        ('D',  500, 1), ('CD', 400, 1),
                        ('C',  100, 3), ('XC', 90, 1),
                        ('L',  50, 1), ('XL', 40, 1),
                        ('X',  10, 3), ('IX', 9, 1),
                        ('V',  5, 1),  ('IV', 4, 1), ('I',  1, 3))
   result, index = 0, 0
   for numeral, value, maxcount in roman_numeral_map:
      count = 0
      while input[index: index +len(numeral)] == numeral:
         count += 1 # how many of this numeral we have
         if count > maxcount:
            raise ValueError, 'input is not a valid roman numeral: %s' % input
         result += value
         index += len(numeral)
   if index < len(input): # There are characters unaccounted for.
      raise ValueError, 'input is not a valid roman numeral: %s'%input
   else:
      return result

These can be simplified a bit more, especially using the Dive Into Python book as inspiration.... Let Python use its fast operations, such as joining and zipping. Looped string concatenation is kind of janky these days:

numeral_map = zip(
    (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1),
    ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')
)

def int_to_roman(i):
    result = []
    for integer, numeral in numeral_map:
        count = int(i / integer)
        result.append(numeral * count)
        i -= integer * count
    return ''.join(result)

def roman_to_int(n):
    n = unicode(n).upper()

    i = result = 0
    for integer, numeral in numeral_map:
        while n[i:i + len(numeral)] == numeral:
            result += integer
            i += len(numeral)
    return result

I know there's no one way to do it, but I was looking for just a simple way to hammer it out for a quick page numbering function, and there was no way I was going to include a huge couple of functions like the originally given ones.

And yes, I know there's no documentation on my code. But 22 lines beats 114 for "just give it to me" code.

Updated to work with Python 3.

numeral_map = tuple(zip(
    (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1),
    ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I')
))

def int_to_roman(i):
    result = []
    for integer, numeral in numeral_map:
        count = i // integer
        result.append(numeral * count)
        i -= integer * count
    return ''.join(result)

def roman_to_int(n):
    i = result = 0
    for integer, numeral in numeral_map:
        while n[i:i + len(numeral)] == numeral:
            result += integer
            i += len(numeral)
    return result