use strict;
use warnings;
use List::Util qw(reduce);

{
  my %rtoa = ( M=>1000, D=>500, C=>100, L=>50, X=>10, V=>5, I=>1 );
  sub roman_to_dec {
    reduce { $a+$b-$a%$b*2 } map { $rtoa{$_} } split//, uc(shift)
  }
}

my @testdata = ( "XLII", "LXIX", "mi" );
for my $r (@testdata) {
  print "$r: ", roman_to_dec($r), "\n";
}

##</code><code>##

XLII: 42
LXIX: 69
mi: 1001

##</code><code>##

  sub roman_to_dec {
    my $t = 0;
    for my $n ( map { $rtoa{$_} } split//, uc(shift) ) {
      $t += $n-$t%$n*2;
    }
    return $t;
  }

##</code><code>##

def roman_to_dec(r, __rtoa = dict(M=1000, D=500, C=100, L=50, X=10, V=5, I=1) ):
  return reduce( lambda t,n: t+n-t%n*2, (__rtoa[c] for c in r.upper()) )

testdata = [ "XLII", "LXIX", "mi" ]
for r in testdata:
  print r, ":", roman_to_dec(r)

##</code><code>##

from functools import reduce
def roman_to_dec(r, __rtoa = dict(M=1000, D=500, C=100, L=50, X=10, V=5, I=1) ):
  return reduce( lambda t,n: t+n-t%n*2, (__rtoa[c] for c in r.upper()) )

testdata = [ "XLII", "LXIX", "mi" ]
for r in testdata:
  print( r, ":", roman_to_dec(r) )

##</code><code>##

{-# OPTIONS_GHC -fglasgow-exts -Wall #-}

import Data.Char (toUpper)
import Data.List (concat, intersperse)

rtoa :: Char -> Int
rtoa 'M' = 1000
rtoa 'D' =  500
rtoa 'C' =  100
rtoa 'L' =   50
rtoa 'X' =   10
rtoa 'V' =    5
rtoa 'I' =    1
rtoa r   = error $ "Invalid rtoa char:" ++ show r

urtoa :: Char -> Int
urtoa = rtoa . toUpper

roman_to_dec :: String -> Int
roman_to_dec = foldl1 (\t n -> t+n-t`mod`n*2) . map urtoa

myshow :: (String -> Int) -> String -> String
myshow fn val = val ++ ": " ++ (show (fn val))

testdata :: [String]
testdata = [ "XLII", "LXIX", "mi" ]

main :: IO ()
main = do
  putStrLn $ (concat $ intersperse "\n" (map (\c -> (myshow roman_to_dec c)) testdata))

##</code><code>##

#include <cctype>
#include <iostream>
#include <string>
#include <vector>
#include <numeric>

using namespace std;

const int romtab[] = {
  0,0,0,0,0,0, 0,   0,  0,0,  // 00-09
  0,0,0,0,0,0, 0,   0,  0,0,  // 10-19
  0,0,0,0,0,0, 0,   0,  0,0,  // 20-29
  0,0,0,0,0,0, 0,   0,  0,0,  // 30-39
  0,0,0,0,0,0, 0,   0,  0,0,  // 40-49
  0,0,0,0,0,0, 0,   0,  0,0,  // 50-59
  0,0,0,0,0,0, 0, 100,500,0,  // 60-69 (C:67,D:68)
  0,0,0,1,0,0,50,1000,  0,0,  // 70-79 (I:73,L:76,M:77)
  0,0,0,0,0,0, 5,   0, 10,0   // 80-89 (V:86,X:88)
};

inline int rtoa(int c)
{
  return romtab[c];
}

inline int accfn(int t, char c)
{
  return t+rtoa(toupper(c))-t%rtoa(toupper(c))*2;
}

int roman_to_dec(const string& s)
{
  return accumulate(s.begin(), s.end(), 0, accfn);
}

int main(int argc, char* argv[])
{
  vector<string> testdata;
  testdata.push_back("XLII");
  testdata.push_back("LXIX");
  testdata.push_back("mi");
  for (vector<string>::const_iterator iter  = testdata.begin();
                                      iter != testdata.end();
                                      ++iter) {
     cout << *iter << ": " << roman_to_dec(*iter) << '\n';
  }
  return 0;
}

##</code><code>##

// Note: there are less than 256 initializers in this table;
// the uninitialized ones are guaranteed by ANSI C to be
// initialized to zero.
const int romtab[256] = {
    0,0,0,0,0,0,   0,   0,   0,   0,  //  00- 09
    0,0,0,0,0,0,   0,   0,   0,   0,  //  10- 19
    0,0,0,0,0,0,   0,   0,   0,   0,  //  20- 29
    0,0,0,0,0,0,   0,   0,   0,   0,  //  30- 39
    0,0,0,0,0,0,   0,   0,   0,   0,  //  40- 49
    0,0,0,0,0,0,   0,   0,   0,   0,  //  50- 59
    0,0,0,0,0,0,   0, 100, 500,   0,  //  60- 69
    0,0,0,1,0,0,  50,1000,   0,   0,  //  70- 79
    0,0,0,0,0,0,   5,   0,  10,   0,  //  80- 89
    0,0,0,0,0,0,   0,   0,   0, 100,  //  90- 99
  500,0,0,0,0,1,   0,   0,  50,1000,  // 100-109
    0,0,0,0,0,0,   0,   0,   5,   0,  // 110-119
   10,0,0,0,0,0,   0,   0,   0,   0   // 120-129
};

// Return the arabic number for a roman letter c.
// Return zero if the roman letter c is invalid.
inline int urtoa(int c)
{
  return romtab[c];
}

inline int accfn(int t, char c)
{
  return t+urtoa(c)-t%urtoa(c)*2;
}