LTD Puzzle VIII - Convert Between Roman and Arabic Numerals

[AlexCuse]

The puzzle this week is simple.

Write a program to convert to (and from) roman numerals. So your program should be able to take the input of 27 and return XXVII, and take MCMLXXXI and return 1981. And of course any other values.

The program must work for all numbers between the upper bound of 4000 and the lower bound of 0 (both non-inclusive)

Bonus points if you check incoming roman numerals for well-formedness (this lists some of the rules: http://en.wikipedia.org/wiki/Roman_nume ... n_numerals)

Have Fun!

[LNBruno]

Okay, so I had this squirreled away in my bag of tricks...(2000)

tsqlLine number Off | Show | Select all

1. CREATE FUNCTION ArabicToRoman(@n INT)
2. --Convert an arabic numeral to roman
3. RETURNS VARCHAR(20)
4. AS
5.  
6. BEGIN
7. --declare @n int
8. --set @n = 1956
9.  
10.    DECLARE @i INT
11.       , @temp CHAR(1)
12.       , @s VARCHAR(20)
13.       , @p1 CHAR(4)
14.       , @p2 CHAR(4)
15.       , @p3 CHAR(4)
16.       , @p4 CHAR(4)
17.      
18.    SET @s = STR(@n, 4, 0)
19.    SET @p1 = ' '
20.    SET @p2 = ' '
21.    SET @p3 = ' '
22.    SET @p4 = ' '
23.    SET @i = LEN(@s)
24.    
25.    WHILE (@i > 0)
26.       BEGIN
27.          SET @temp = UPPER(SUBSTRING (@s, @i, 1))
28.          IF LEN(@s) - @i = 0
29.              SET @p1 =
30.              CASE UPPER(SUBSTRING(@s, @i, 1))
31.                 WHEN '1' THEN 'I'
32.                 WHEN '2' THEN 'II'
33.                 WHEN '3' THEN 'III'
34.                 WHEN '4' THEN 'IV'
35.                 WHEN '5' THEN 'V'
36.                 WHEN '6' THEN 'VI'
37.                 WHEN '7' THEN 'VII'
38.                 WHEN '8' THEN 'VIII'
39.                 WHEN '9' THEN 'IX'
40.                 ELSE ' '
41.              END
42.          IF LEN(@s) - @i = 1
43.              SET @p2 =
44.              CASE UPPER(SUBSTRING(@s, @i, 1))
45.                 WHEN '1' THEN 'X'
46.                 WHEN '2' THEN 'XX'
47.                 WHEN '3' THEN 'XXX'
48.                 WHEN '4' THEN 'XL'
49.                 WHEN '5' THEN 'L'
50.                 WHEN '6' THEN 'LX'
51.                 WHEN '7' THEN 'LXX'
52.                 WHEN '8' THEN 'LXXX'
53.                 WHEN '9' THEN 'XC'
54.                ELSE ' '
55.           END
56.          IF LEN(@s) - @i = 2
57.              SET @p3 =
58.              CASE UPPER(SUBSTRING(@s, @i, 1))
59.                 WHEN '1' THEN 'C'
60.                 WHEN '2' THEN 'CC'
61.                 WHEN '3' THEN 'CCC'
62.                 WHEN '4' THEN 'CD'
63.                 WHEN '5' THEN 'D'
64.                 WHEN '6' THEN 'DC'
65.                 WHEN '7' THEN 'DCC'
66.                 WHEN '8' THEN 'DCCC'
67.                 WHEN '9' THEN 'CM'
68.                ELSE ' '
69.              END
70.          IF LEN(@s) - @i = 3
71.              SET @p4 =
72.              CASE UPPER(SUBSTRING(@s, @i, 1))
73.                 WHEN '1' THEN 'M'
74.                 WHEN '2' THEN 'MM'
75.                 WHEN '3' THEN 'MMM'
76.                 WHEN '4' THEN 'MMMM'
77.                ELSE ' '
78.              END
79.          SET @i = @i - 1
80.    END
81.       SET @s = @p4 + @p3 + @p2 + @p1
82.       SET @s = REPLACE(@s,' ','')
83.    --PRINT @s
84.    RETURN @s
85.  END
86.  
87. CREATE FUNCTION RomanToArabic(@s VARCHAR(20))
88. --Convert a roman numeral to arabic
89. RETURNS INT
90. AS
91.  
92. BEGIN
93. --declare @s varchar(20)
94. --set @s = 'MCMLVI'
95.  
96.    DECLARE @f INT
97.       , @k INT
98.       , @z INT
99.       , @z1 INT
100.      
101.    SET @f = LEN(@s)
102.    SET @k = 0
103.    SET @z1 = 0
104.    
105.    WHILE (@f > 0)
106.    BEGIN
107.        SET @z =
108.        CASE UPPER(SUBSTRING(@s, @f, 1))
109.           WHEN 'I' THEN 1
110.           WHEN 'V' THEN 5
111.           WHEN 'X' THEN 10
112.           WHEN 'L' THEN 50
113.           WHEN 'C' THEN 100
114.           WHEN 'D' THEN 500
115.           WHEN 'M' THEN 1000
116.        END
117.        
118.       IF @z1 > @z
119.           SET @k = @k - @z
120.       ELSE
121.           SET @k = @k + @z
122.           SET @z1 = @z
123.          SET @f = @f - 1
124.  
125.    END
126.    --PRINT @k
127.    RETURN @k
128. END

Code is hidden, SHOW

[LNBruno]

Rats! Left off the final END in the first blob o' code.

[chrissie1]

Rats! Left off the final END in the first blob o' code.

you can edit your code. Like me I made it a hidecode tags instead of hide tags.

[AlexCuse]

Mike, please tell me it was squirelled away from a past puzzle, and not production code

[LNBruno]

Hey, cool! Didn't know I could edit my post, chrissie! Thanks.

And Alex, of course it was from a past puzzle! Definitely, absolutely not, I repeat, NOT any production code I ever had to write...

Okay, okay! I confess! It was production code.

[LNBruno]

DOH! Edit button, ID10T!

Did I mention that I'm glad it's Friday?

[Remou]

Hey, cool! Didn't know I could edit my post, chrissie! Thanks.

And Alex, of course it was from a past puzzle! Definitely, absolutely not, I repeat, NOT any production code I ever had to write...

Okay, okay! I confess! It was production code.

Do you use papiri or wax tablets for your code?

[LNBruno]

Remou asked: Do you use papiri or wax tablets for your code?

We're still on Stone Tablets (beta).

[Remou]

Ooh! Silicon chips!

[ca8msm]

Here's an ASP.NET version:

vbnetLine number Off | Show | Select all

1. Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
2.         Response.Write(ToRomanNumeral(27) & "<br>")
3.         Response.Write(FromRomanNumeral("MCMLXXXI"))
4.     End Sub
5.  
6.     Function ToRomanNumeral(ByVal Number As Integer) As String
7.         Select Case Number
8.             Case Is >= 889 : Return "M" & ToRomanNumeral(Number - 1000)
9.             Case Is >= 389 : Return "D" & ToRomanNumeral(Number - 500)
10.             Case Is >= 89 : Return "C" & ToRomanNumeral(Number - 100)
11.             Case Is >= 39 : Return "L" & ToRomanNumeral(Number - 50)
12.             Case Is >= 9 : Return "X" & ToRomanNumeral(Number - 10)
13.             Case Is >= 4 : Return "V" & ToRomanNumeral(Number - 5)
14.             Case Is >= 1 : Return "I" & ToRomanNumeral(Number - 1)
15.             Case Is <= -889 : Return "M" & ToRomanNumeral(Number + 1000)
16.             Case Is <= -389 : Return "D" & ToRomanNumeral(Number + 500)
17.             Case Is <= -89 : Return "C" & ToRomanNumeral(Number + 100)
18.             Case Is <= -39 : Return "L" & ToRomanNumeral(Number + 50)
19.             Case Is <= -9 : Return "X" & ToRomanNumeral(Number + 10)
20.             Case Is <= -4 : Return "V" & ToRomanNumeral(Number + 5)
21.             Case Is <= -1 : Return "I" & ToRomanNumeral(Number + 1)
22.             Case Else : Return String.Empty
23.         End Select
24.     End Function
25.  
26.     Function FromRomanNumeral(ByVal Numeral As String) As Decimal
27.         Dim RomanNumerals(Numeral.Length) As Integer
28.         Dim Total As Integer
29.         For i As Integer = 0 To Numeral.Length - 1
30.             Select Case Numeral.Substring(i, 1)
31.                 Case "M" : RomanNumerals(i) = 1000
32.                 Case "D" : RomanNumerals(i) = 500
33.                 Case "C" : RomanNumerals(i) = 100
34.                 Case "L" : RomanNumerals(i) = 50
35.                 Case "X" : RomanNumerals(i) = 10
36.                 Case "V" : RomanNumerals(i) = 5
37.                 Case "I" : RomanNumerals(i) = 1
38.             End Select
39.         Next
40.         For i As Integer = 0 To Numeral.Length - 1
41.             If i = Numeral.Length Then
42.                 Total += RomanNumerals(i)
43.             Else
44.                 If RomanNumerals(i) >= RomanNumerals(i + 1) Then
45.                     Total += RomanNumerals(i)
46.                 Else
47.                     Total -= RomanNumerals(i)
48.                 End If
49.             End If
50.         Next
51.         Return Total
52.     End Function
53.  

Code is hidden, SHOW

[shamsm]

Here is a solution in java which does some validation on the roman input,
the roman digits are represented by enums

javaLine number Off | Show | Select all

1. public final class RomanNumerals
2. {
3.   private RomanNumerals() {
4.     throw new IllegalStateException("Do not create instance of RomanNumerals");
5.   }
6.  
7.   enum RomanDigit
8.   {
9.     // ONE
10.     I(1),
11.     // FIVE
12.     V(5),
13.     // TEN
14.     X(10),
15.     // FIFTY
16.     L(50),
17.     // HUNDRED
18.     C(100),
19.     // FIVE HUNDRED
20.     D(500),
21.     // ONE THOUSAND
22.     M(1000), ;
23.  
24.     private final int mDecimalValue;
25.  
26.     private final int mLogTen;
27.  
28.     RomanDigit(final int pDecimalValue) {
29.       mDecimalValue = pDecimalValue;
30.       mLogTen = (int) Math.ceil(Math.log(mDecimalValue) / Math.log(10));
31.     }
32.  
33.     public int decimalValue() {
34.       return mDecimalValue;
35.     }
36.  
37.     public int logCeiled() {
38.       return mLogTen;
39.     }
40.  
41.     public static RomanDigit[] reverseValues() {
42.       final RomanDigit[] eResult = values();
43.  
44.       final int eSize = eResult.length;
45.       for( int i = 0; i < eSize / 2; i++ ) {
46.         RomanDigit eTemp = eResult[i];
47.         eResult[i] = eResult[eSize - i - 1];
48.         eResult[eSize - i - 1] = eTemp;
49.       }
50.  
51.       return eResult;
52.     }
53.   }
54.  
55.   /**
56.    * expect a number (0, 4000)
57.    */
58.   public static String getRomanValue(final int pValue) {
59.     final StringBuilder eResult = new StringBuilder(10);
60.  
61.     int eValueRemaining = pValue;
62.     int eTenValue = 1000;
63.     while( eTenValue > 0 ) {
64.  
65.       int eDigitToGet = eValueRemaining / eTenValue;
66.       if( eDigitToGet != 0 ) {
67.         eResult.append(getRepresentation(eDigitToGet, eTenValue));
68.       }
69.       eValueRemaining = eValueRemaining % eTenValue;
70.       eTenValue /= 10;
71.     }
72.  
73.     return eResult.toString();
74.   }
75.  
76.   private static String getRepresentation(final int pDigit,
77.       final int pPowerOfTen) {
78.     final StringBuilder eResult = new StringBuilder(4);
79.  
80.     switch( pDigit ) {
81.       case 9:
82.         eResult.append(getRomanRepresentation(pPowerOfTen));
83.         eResult.append(getRomanRepresentation(pPowerOfTen * 10));
84.         break;
85.       case 4:
86.         eResult.append(getRomanRepresentation(pPowerOfTen));
87.         eResult.append(getRomanRepresentation(pPowerOfTen * 5));
88.         break;
89.       default:
90.         eResult.append(getRomanRepresentation(pPowerOfTen * pDigit));
91.     }
92.  
93.     return eResult.toString();
94.   }
95.  
96.   /**
97.    * return roman representation with digits in decreasing order. e.g. will
98.    * return IIII and not IV
99.    */
100.   private static String getRomanRepresentation(final int pValue) {
101.     final StringBuilder eResult = new StringBuilder(4);
102.     final RomanDigit[] eDigits = RomanDigit.reverseValues();
103.  
104.     int eValueRemaining = pValue;
105.     for( int i = 0; i < eDigits.length; i++ ) {
106.       final RomanDigit eLoopDigit = eDigits[i];
107.  
108.       if( eValueRemaining == 0 ) {
109.         break;
110.       }
111.  
112.       if( eLoopDigit.decimalValue() <= eValueRemaining ) {
113.         eResult.append(eLoopDigit.toString());
114.         eValueRemaining -= eLoopDigit.decimalValue();
115.         // iterate for this digit again
116.         i--;
117.       }
118.     }
119.  
120.     return eResult.toString();
121.   }
122.  
123.   /**
124.    * expect a string of length at least 1.
125.    */
126.   public static int getDecimalValue(final String pRomanString) {
127.  
128.     RomanDigit eLeadingDigit = getRomanDigit(pRomanString, pRomanString
129.         .length() - 1);
130.     int eResult = eLeadingDigit.decimalValue();
131.  
132.     RomanDigit ePrevDigit = eLeadingDigit;
133.     for( int i = pRomanString.length() - 2; i >= 0; i-- ) {
134.       RomanDigit eLoopDigit = getRomanDigit(pRomanString, i);
135.  
136.       if( eLoopDigit.ordinal() < ePrevDigit.ordinal() ) {
137.         if( ePrevDigit.logCeiled() - eLoopDigit.logCeiled() != 1 ) {
138.           // a symbol representing 10^n may not precede any symbol larger than
139.           // 10^(n+1), e.g. IX is valid, but not IL. VX is also invalid, we
140.           // could just write V.
141.           throw new IllegalArgumentException(eLoopDigit.toString()
142.               + " may not precede " + ePrevDigit.toString());
143.         } else if( ePrevDigit.ordinal() != eLeadingDigit.ordinal() ) {
144.           // At most one digit of lower value can precede a leading Digit,
145.           // i.e., allow IIX but not IVX
146.           throw new IllegalArgumentException(eLoopDigit.toString()
147.               + " may not precede " + ePrevDigit.toString());
148.         }
149.         eResult -= eLoopDigit.decimalValue();
150.  
151.       } else if( eLoopDigit.ordinal() == ePrevDigit.ordinal() ) {
152.         if( ePrevDigit.ordinal() < eLeadingDigit.ordinal() ) {
153.           eResult -= eLoopDigit.decimalValue();
154.         } else if( ePrevDigit.ordinal() == eLeadingDigit.ordinal() ) {
155.           eResult += eLoopDigit.decimalValue();
156.         } else {
157.           throw new IllegalStateException("Unexpected state processing index: "
158.               + i);
159.         }
160.  
161.       } else {
162.         if( eLoopDigit.ordinal() < eLeadingDigit.ordinal() ) {
163.           // we've experience something like VIX, which is invalid
164.           throw new IllegalArgumentException(eLoopDigit.toString()
165.               + " at index " + i + " may not precede "
166.               + eLeadingDigit.toString());
167.         }
168.         eResult += eLoopDigit.decimalValue();
169.         eLeadingDigit = eLoopDigit;
170.       }
171.       ePrevDigit = eLoopDigit;
172.     }
173.  
174.     return eResult;
175.   }
176.  
177.   private static RomanDigit getRomanDigit(final String pRomanString,
178.       final int eIndex) {
179.     final String eLastChar = Character.toString(pRomanString.charAt(eIndex));
180.     try {
181.       return RomanDigit.valueOf(eLastChar);
182.     } catch( IllegalArgumentException ile ) {
183.       throw new IllegalArgumentException("Invalid Roman Character: '"
184.           + eLastChar + "' at index: " + eIndex);
185.     }
186.   }
187.  
188.   public static void main(String[] args) {
189.  
190.     assertEqual(getDecimalValue("VIII"), 8);
191.     assertEqual(getDecimalValue("IIX"), 8);
192.     assertEqual(getDecimalValue("IX"), 9);
193.     assertEqual(getDecimalValue("XI"), 11);
194.     assertEqual(getDecimalValue("XIV"), 14);
195.     assertEqual(getDecimalValue("XV"), 15);
196.     assertEqual(getDecimalValue("XCIX"), 99);
197.     assertEqual(getDecimalValue("DCLXVI"), 666);
198.     assertEqual(getDecimalValue("MCDXLIV"), 1444);
199.     assertEqual(getDecimalValue("MDCLXVI"), 1666);
200.     assertEqual(getDecimalValue("MCMXLV"), 1945);
201.     assertEqual(getDecimalValue("MCMLXXXI"), 1981);
202.     assertEqual(getDecimalValue("MCMXCVII"), 1997);
203.     assertEqual(getDecimalValue("MCMXCIX"), 1999);
204.     assertEqual(getDecimalValue("MMVIII"), 2008);
205.     assertEqual(getDecimalValue("MMD"), 2500);
206.  
207.     assertEqual("VIII", getRomanValue(8));
208.     assertEqual("IX", getRomanValue(9));
209.     assertEqual("XI", getRomanValue(11));
210.     assertEqual("XIV", getRomanValue(14));
211.     assertEqual("XV", getRomanValue(15));
212.     assertEqual("XCIX", getRomanValue(99));
213.     assertEqual("DCLXVI", getRomanValue(666));
214.     assertEqual("MCDXLIV", getRomanValue(1444));
215.     assertEqual("MDCLXVI", getRomanValue(1666));
216.     assertEqual("MCMXLV", getRomanValue(1945));
217.     assertEqual("MCMLXXXI", getRomanValue(1981));
218.     assertEqual("MCMXCVII", getRomanValue(1997));
219.     assertEqual("MCMXCIX", getRomanValue(1999));
220.     assertEqual("MMVIII", getRomanValue(2008));
221.     assertEqual("MMD", getRomanValue(2500));
222.  
223.   }
224.  
225.   public static void assertEqual(final int pFirst, final int pSecond) {
226.     if( pFirst != pSecond ) {
227.       throw new AssertionError(pFirst + " is not equal to " + pSecond);
228.     }
229.   }
230.  
231.   public static void assertEqual(final Object pFirst, final Object pSecond) {
232.     if( !pFirst.equals(pSecond) ) {
233.       throw new AssertionError(pFirst + " is not equal to " + pSecond);
234.     }
235.   }
236. }
237.  

Code is hidden, SHOW

[b3orn]

My solution. Not fully completed (some checks should be implemented) but it (seems to) works. I used some test from shamsm (thanks).

pythonLine number Off | Show | Select all

1. roman = ['I', 'V', 'X', 'L', 'C', 'D', 'M']
2. roman_values = (1, 5, 10, 50, 100, 500, 1000)
3.  
4. def romanValue(value, first, mid="", last=""):
5.  
6.     i = value / 5
7.     j = value % 5
8.  
9.     if j <= 3:
10.         return mid * i + first * j
11.     elif j == 4:
12.         return first + (i == 0 and mid or last)
13.     return mids
14.    
15. def toRoman(value, depth=0):
16.     if value <= 0 or value >= 4000:
17.         if depth == 0:
18.             raise ValueError("Valid values are in range [1 - 3999]")
19.         else:
20.             return ""
21.  
22.     current = value % 10
23.     next = value / 10
24.  
25.     index = depth * 2
26.     roman_letters = roman[index:index + 3]
27.  
28.     result = romanValue(current, *roman_letters)
29.  
30.     return toRoman(next, depth + 1) + result
31.  
32. def toArabic(value, previous=0):
33.     current = roman_values[roman.index(value[0])]
34.     if len(value) > 1:  
35.         arabic = toArabic(value[1:], current)
36.     else:
37.         arabic = current
38.     if previous >= current:  
39.         return previous + arabic
40.     return arabic - previous
41.  
42. print toArabic("MCMLXXXI"), 1981
43. print toRoman(27), "XXVII"
44.  
45. print toArabic("VIII"), 8
46. print toArabic("IX"), 9
47. print toArabic("XI"), 11
48. print toArabic("XIV"), 14
49. print toArabic("XV"), 15
50. print toArabic("XCIX"), 99
51. print toArabic("DCLXVI"), 666
52. print toArabic("MCDXLIV"), 1444
53. print toArabic("MDCLXVI"), 1666
54. print toArabic("MCMXLV"), 1945
55. print toArabic("MCMLXXXI"), 1981
56. print toArabic("MCMXCVII"), 1997
57. print toArabic("MCMXCIX"), 1999
58. print toArabic("MMVIII"), 2008
59. print toArabic("MMD"), 2500
60.  
61. print toRoman(8), "VIII"
62. print toRoman(9), "IX"
63. print toRoman(11), "XI"
64. print toRoman(14), "XIV"
65. print toRoman(15), "XV"
66. print toRoman(99), "XCIX"
67. print toRoman(666), "DCLXVI"
68. print toRoman(1444), "MCDXLIV"
69. print toRoman(1666), "MDCLXVI"
70. print toRoman(1945), "MCMXLV"
71. print toRoman(1981), "MCMLXXXI"
72. print toRoman(1997), "MCMXCVII"
73. print toRoman(1999), "MCMXCIX"
74. print toRoman(2008), "MMVIII"
75. print toRoman(2500), "MMD"

Code is hidden, SHOW

[tisodotsk]

PHP, quick and dirty (without validations):

phpLine number Off | Show | Select all

1. <?php
2. //------------------------------------------------------------------------------
3. function RomanToArabic($roman)
4. {
5.     $conversion=array('CM' => 900, 'CD' => 400, 'XC' => 90, 'XL' => 40, 'IX' => 9, 'IV' => 4,
6.                       'M' => 1000, 'D' => 500, 'C' => 100, 'L' => 50, 'X' => 10, 'V' => 5, 'I' => 1);
7.     foreach($conversion as $key => $val){$conversion[$key]='|'.$val;}
8.     $tmp=str_replace(array_keys($conversion), array_values($conversion), $roman);
9.     $parts=explode('|', substr($tmp, 1));
10.     return array_sum($parts);
11. }
12. //------------------------------------------------------------------------------
13. function ArabicToRoman($arabic)
14. {
15.     $roman='';
16.     $conversion=array(1 => 'I', 5 => 'V', 10 => 'X', 50 => 'L', 100 => 'C', 500 => 'D', 1000 => 'M');
17.     $numbers=explode('|', substr(strrev(chunk_split($arabic, 1, '|')), 1));
18.     $multiplier=1;
19.     foreach($numbers as $number){
20.         if($number == 0){}
21.         elseif($number == 9){$roman=$conversion[$multiplier].$conversion[10*$multiplier].$roman;}
22.         elseif($number == 5){$roman=$conversion[$number*$multiplier].$roman;}
23.         elseif($number == 4){$roman=$conversion[$multiplier].$conversion[5*$multiplier].$roman;}
24.         elseif($number < 4){$roman=str_repeat($conversion[$multiplier], $number).$roman;}
25.         else{$roman=$conversion[5*$multiplier].str_repeat($conversion[$multiplier], $number-5).$roman;}
26.         $multiplier=$multiplier*10;
27.     }
28.     return $roman;
29. }
30. //------------------------------------------------------------------------------
31. for($i=1; $i < 4000; $i++){
32.     echo $i.' -> '.ArabicToRoman($i).' -> '.RomanToArabic(ArabicToRoman($i)).'<br>';
33. }
34. //------------------------------------------------------------------------------
35. ?>

Code is hidden, SHOW

Output, first 10 lines:

textLine number Off | Hide | Select all

1. 1 -> I -> 1
2. 2 -> II -> 2
3. 3 -> III -> 3
4. 4 -> IV -> 4
5. 5 -> V -> 5
6. 6 -> VI -> 6
7. 7 -> VII -> 7
8. 8 -> VIII -> 8
9. 9 -> IX -> 9
10. 10 -> X -> 10

[chrissie1]

Validation is for sissies

You just have to select smarter users.