Haskell: Integers -> Roman Numerals

Question

So, I've got this interesting practical exercise for a problem sheet: Convert integers (less than 5000) to Roman numerals. Here's the code I've written; however, I'm having difficulty loading the script in GHCI (parse error on input `='). Any ideas?

units, tens, hundreds, thousands :: [String]
units=["I", "II", "III", "IV", "V", "VI", "VII", "IIX", "IX"]
tens=["X", "XX", "XXX", "XL", "L", "LX", "LXX", "XXC", "XC"]
hundreds=["C", "CC", "CCC", "CD", "D", "DC", "DCC", "CCM","CM"]
thousands=["M", "MM", "MMM", "MV", "V"]

combine :: (Int,Int,Int,Int) -> String
combine (0,0,0,u)   = units !! u
combine (0,0,t+1,0) = tens !! t
combine (0,0,t+1,u) = tens !! t ++ units !! u
combine (0,h+1,0,0) = hundreds !! h
combine (0,h+1,t+1,0) = hundreds !! h ++ tens !! t
combine (0,h+1,t+1,u)   = hundreds !! h ++ tens !! t ++ units !! u
combine (f+1,0,0,0) = thousands !! f
combine (f+1,h+1,0,0)   = thousands !! f ++ hundreds !! h
combine (f+1,h+1,t+1,0) = thousands !! f ++ hundreds !! h ++ tens !! t
combine (f+1,h+1,t+1,u) = thousands !! f ++ hundreds !! h ++ tens !! t ++ units !! u

As most often, the line number seems to be totally uninteresting .... this explains also why you can't solve this on your own. — Ingo, Oct 30 '13 at 12:01
Or I'm have bad memory or there is no `IIX`, there is `VIII`, etc. — Hauleth, Oct 30 '13 at 12:09
I would be surprised if you get many marks for this. I'm betting the person who set the question is expecting a function with signature `:: Int -> String` or possibly `::Int -> Maybe String` but not what you have done. Taking four separate `Ints` just makes all this more fragile, as well. Do you not realise it's quite easy to turn an Int into a list of Ints, each of which will be between 0 and 9? — itsbruce, Oct 30 '13 at 15:37
`numeralise i = foldr (flip (++)) "" $ map (\(ns, d) -> ns !! (read d)) $ zip numerals $ map (: []) $ reverse $ show i` - Now, I wonder what `numerals` might be? — itsbruce, Oct 30 '13 at 18:29
Are n+k patterns still supported? Also,, how do you plan to convert 1001? — n. m. could be an AI, Oct 13 '17 at 08:47

score 2 · Answer 1 · answered Oct 30 '13 at 12:07

There are actually several syntax errors in this program (Edit: thanks to @Lukasz's edits, now there's only one syntax error). But the one you're asking about is caused by the fact that you can't just create a binding in ghci. Where in a program you write

a = 1

in ghci you must write

let a = 1

otherwise you will get the parse error on input `=' error.

I would recommend you to put your program in a file and compile it with ghc or run it with runhaskell instead of inserting lets, it'll be more convenient for future work and bugfixing.

score 0 · Answer 2 · answered Aug 02 '16 at 15:52

I have written a module to deal with the conversions between integers and roman numbers. However, there are 3 shortcomings in my module.

The max roman number that my module can deal with will not exceed than 4999, because I assumed that the largest roman unit is "M" and "MMMM" is not a valid roman number by the rules.
I did not use Maybe in the function "findKey" to avoid unexpected keys since I had not mastered applicative, functor and monad very well.

I have no idea on how to finish prettyRoman2, which will looking for the combinations "VIV", "LXL" and "DCD" in the string of a roman number, and replace them by "IX","XC" and "CM" respectively.

 module Roman 
( roman2Dec
 , dec2Roman
) where

import Data.List (isInfixOf)

-- The max number the program can deal with will not exceed than 4999

romanUnits :: [(Char, Int)]
romanUnits = [('I', 1), ('V', 5), ('X', 10), ('L', 50), ('C', 100), ('D', 500), ('M', 1000)]

romanDividers :: [Int]
romanDividers = reverse $ map snd romanUnits

romanDigits :: [Char]
romanDigits  = reverse $ map fst romanUnits

-- short divide n by each of those in dividers
shortDivide :: Int -> [Int] -> [Int]
shortDivide n [] = []
shortDivide n dividers = let (quotient, remainder) = n `divMod` (head dividers)
                         in quotient : shortDivide remainder (tail dividers)

dec2Roman :: Int -> String
dec2Roman n = concat $ map prettyRoman1 (zipWith (\x y -> replicate x y) (shortDivide n romanDividers) romanDigits)

prettyRoman1 :: String -> String
prettyRoman1 roman
  | roman == "IIII" = "IV"
  | roman == "XXXX" = "XL"
  | roman == "CCCC" = "CD"
  | otherwise = roman

-- prettyRoman2: Replace VIV, LXL, DCD with IX, XC, and CM respectively. 
-- After that, the dec2Roman will be modifed as dec2Roman' = prettyRoman2 dec2Roman
prettyRoman2 :: String -> String
prettyRoman2 = undefined

findKey :: Eq a => a -> [(a, b)] -> b
findKey key = snd . head . filter (\(k, v) -> k == key)

romanValue :: Char -> Int
romanValue c = findKey c romanUnits

roman2Dec :: String -> Int
roman2Dec [] = 0
roman2Dec [x] = romanValue x
roman2Dec (x:y:xs)
  | romanValue x < romanValue y  = (-1) * romanValue x  + roman2Dec (y:xs)
  | otherwise = romanValue x + roman2Dec (y:xs)

I don't think you ever want something like `VIV` to show up in am intermediate form. By the time you get there, you've probably already lost. — dfeuer, Aug 02 '16 at 23:08
I don't think your comment make any sense, because event a roman people write their particular decimal will meet the same problem as mine. Suppose he meet 4 identical roman digits, he will use a lager unit to replace the last 3 ones, such as IIII yields to IV. After that , he will find the new produced larger units can be combinated with the same units before them, like VIV, LXL, etc. I don't think you can find a way to avoid it. — Storm-Eyes, Aug 03 '16 at 13:35

Redu · Answer 3 · 2017-10-13T08:40:07.203

A little late but just for the record I have ported my code from JS to Haskell here. I believe it is one of the most efficient Integer to Roman numeral converters. However as of now it's only fine up to 3999.

import qualified Data.Map.Lazy as M
import Data.Bool (bool)
import Data.List (unfoldr)

numerals :: M.Map Int Char
numerals = M.fromList [(0,'I'),(1,'V'),(2,'X'),(3,'L'),(4,'C'),(5,'D'),(6,'M')]

toDigits :: Int -> [Int]
toDigits = unfoldr (\x -> bool Nothing (Just (rem x 10, div x 10)) (x > 0))

getFromMap :: Int -> M.Map Int Char -> Char
getFromMap = M.findWithDefault '_'

getNumeral :: (Int,Int) -> String
getNumeral t | td == 0   = ""
             | td <  4   = replicate td $ getFromMap (2 * ti) numerals
             | td == 4   = getFromMap (2 * ti) numerals : [getFromMap (2 * ti + 1) numerals]
             | td <  9   = getFromMap (2 * ti + 1) numerals : replicate (td - 5) (getFromMap (2 * ti) numerals)
             | otherwise = getFromMap (2 * ti) numerals : [getFromMap (2 * ti + 2) numerals]
               where ti  = fst t -- indices
                     td  = snd t -- digits

dec2roman :: Int -> String
dec2roman = foldl (\r t -> getNumeral t ++ r) "" . zipWith (,) [0..] . toDigits

*Main> dec2roman 1453
"MCDLIII"

Haskell: Integers -> Roman Numerals

3 Answers3