Kata: Roman Numerals in Clojure

I've just done the Roman Numerals kata in Clojure.

I used this description of roman numerals, On Roman Numerals, and continued the kata to also convert numbers over 3000.

These are the tests using Midje that I wrote to test-drive the solution:

	(ns roman-numerals.core-test
	(:use midje.sweet)
	(:use [roman-numerals.core]))
	(facts
	"about arabic to roman numerals conversion"
	(fact "it converts numbers until 10"
	(arabic-to-roman 1) => "I"
	(arabic-to-roman 2) => "II"
	(arabic-to-roman 3) => "III"
	(arabic-to-roman 4) => "IV"
	(arabic-to-roman 5) => "V"
	(arabic-to-roman 8) => "VIII"
	(arabic-to-roman 9) => "IX"
	(arabic-to-roman 10) => "X")
	(fact "it converts numbers from 10 to 39"
	(arabic-to-roman 13) => "XIII"
	(arabic-to-roman 14) => "XIV"
	(arabic-to-roman 25) => "XXV"
	(arabic-to-roman 28) => "XXVIII"
	(arabic-to-roman 39) => "XXXIX")
	(fact "it converts numbers from 40 to 89"
	(arabic-to-roman 40) => "XL"
	(arabic-to-roman 49) => "XLIX"
	(arabic-to-roman 50) => "L"
	(arabic-to-roman 89) => "LXXXIX")
	(fact "it converts numbers from 90 to 199"
	(arabic-to-roman 90) => "XC"
	(arabic-to-roman 99) => "XCIX"
	(arabic-to-roman 100) => "C"
	(arabic-to-roman 199) => "CXCIX")
	(fact "it converts numbers from 200 to 1000"
	(arabic-to-roman 200) => "CC"
	(arabic-to-roman 250) => "CCL"
	(arabic-to-roman 400) => "CD"
	(arabic-to-roman 499) => "CDXCIX"
	(arabic-to-roman 500) => "D"
	(arabic-to-roman 899) => "DCCCXCIX"
	(arabic-to-roman 900) => "CM"
	(arabic-to-roman 999) => "CMXCIX"
	(arabic-to-roman 1000) => "M")
	(fact "it converts numbers from 1001 to 3999"
	(arabic-to-roman 1100) => "MC"
	(arabic-to-roman 1200) => "MCC"
	(arabic-to-roman 2250) => "MMCCL"
	(arabic-to-roman 3400) => "MMMCD"
	(arabic-to-roman 3499) => "MMMCDXCIX"
	(arabic-to-roman 3500) => "MMMD"
	(arabic-to-roman 3899) => "MMMDCCCXCIX"
	(arabic-to-roman 3900) => "MMMCM"
	(arabic-to-roman 3999) => "MMMCMXCIX"
	(arabic-to-roman 3000) => "MMM")
	(fact "it converts numbers over 3999"
	(arabic-to-roman 4000) => "--\nIV"
	(arabic-to-roman 4001) => "--\nIVI"
	(arabic-to-roman 3999005) => "---------\nMMMCMXCIXV"
	(arabic-to-roman 4000000) => "--\n--\nIV"
	(arabic-to-roman 4000025) => "--\n--\nIVXXV"))

view raw roman-numerals.core-test.clj hosted with ❤ by GitHub

and this is the code:

	(ns roman-numerals.core)
	(declare huge-roman-numeral convert roman-symbols)
	(defn arabic-to-roman [arabic]
	(cond
	(<= arabic 10) (convert arabic :until-10)
	(<= arabic 100) (str (convert (quot arabic 10) :until-100)
	(arabic-to-roman (mod arabic 10)))
	(<= arabic 1000) (str (convert (quot arabic 100) :until-1000)
	(arabic-to-roman (mod arabic 100)))
	(<= arabic 3999) (str (convert (quot arabic 1000) :until-3999)
	(arabic-to-roman (mod arabic 1000)))
	:else (huge-roman-numeral arabic)))
	(def ^:private roman-symbols
	{:until-10 "IVX"
	:until-100 "XLC"
	:until-1000 "CDM"
	:until-3999 "M "})
	(defn- convert [arabic in-range]
	(let [[from medium to] (roman-symbols in-range)]
	(cond
	(= arabic 0) ""
	(= arabic 10) (str to (convert (- arabic 10) in-range))
	(= arabic 4) (str from medium)
	(>= arabic 9) (str from to (convert (- arabic 9) in-range))
	(>= arabic 5) (str medium (convert (- arabic 5) in-range))
	:else (str from (convert (- arabic 1) in-range)))))
	(defn- thousand-bar [size]
	(str (apply str (repeat (count size) "-")) "\n"))
	(defn- times-thousand [arabic]
	(loop [n arabic times 0]
	(if (<= n 3999)
	times
	(recur (quot n 1000) (+ times 1)))))
	(defn- pow [m n]
	(reduce * (repeat n m)))
	(defn- huge-roman-numeral [arabic]
	(let [times (times-thousand arabic)
	div (pow 1000 times)
	thousand-multiple (arabic-to-roman (quot arabic div))
	horizontal-bar (thousand-bar thousand-multiple)]
	(str
	(apply str (repeat times horizontal-bar))
	thousand-multiple
	(arabic-to-roman (mod arabic div)))))

view raw roman-numerals.core.clj hosted with ❤ by GitHub

It's possible to convert numbers over 3999:

	user=> (println (arabic-to-roman 3999005))
	---------
	MMMCMXCIXV
	nil
	user=> (println (arabic-to-roman 3999050))
	---------
	MMMCMXCIXL
	nil
	user=> (println (arabic-to-roman 3999150))
	---------
	MMMCMXCIXCL
	nil
	user=> (println (arabic-to-roman 4000150))
	--
	--
	IVCL
	nil
	user=> (println (arabic-to-roman 3999000150))
	---------
	---------
	MMMCMXCIXCL
	nil

view raw roman-numerals-repl.sh hosted with ❤ by GitHub

To document the TDD process I commited the code after every passing test and every refactor.
You can find the commits step by step here.

It's been difficult to derive this recursive algorithm only using strict TDD, but it was also a lot of fun.

You can find the resulting code in GitHub.


Update: Recently I revisited the Roman Numerals kata and got to a simpler solution.