-- Shakespeare, Hamlet
Act III, Scene IV, Line 211
The idea of the Roman Numeral kata is that given a number between 1 and we'll say 4999, the number will be converted into the Roman numeral form.
f(1) = "I"
f(2) = "II"
f(3) = "III"
f(4) = "IV"
f(5) = "V"
...
f(4999) = "MMMMCMXCIX"
You can test a value using Google's search by typing the number and "to roman". Try searching for "299 to roman" to test it out.
At work, we have been using the Roman Numeral kata for interviewing candidates. The idea is that we get an idea of what it is like to work with the person and they get an idea of what it is like to work with us. As an added bonus there is a good chance that we will learn something new from each other in the process.
On one such interview recently, we had a candidate do something rather interesting. Typically a candidate will just start with a series of if statements, some candidates will replace the ifs with an associative data structure (called dictionary in C#), but most will not. This candidate did a transformation of the input into a string of "I"s and then replace those with the Roman numeral. They did not ended up finishing or even coming to a general pattern, but I found this idea interesting and ran with it coming up with a C# one liner.
We see in the code above a few different things.
To make this a REPL one liner we create a Func which takes an integer and returns a string, we then start the lambda expression with the bond variable of number. (In the refactoring done on the candidates code this was all in a single return statement in a method not a Func variable, but when I redid it for this post I did it on the Mono REPL as a Func variable.)
Func<int, string> toRoman = (number) =>
After that we have our associative array, which allows us to look up each of the transformation that we will be doing, this is very useful since to add another transformation we just need to add an entry to the associative array. (I've done this kind of thing in real world application but I normally will make the look up be a private member of the class.)
**Note, you do not need the "I" entry in the associative array do the the seed value of the fold, but we'll leave it in there since it is from the more general way of doing this kata.**new Dictionary<int, string>{{1000, "M"},{ 900, "CM"},{ 500, "D"},{ 400, "CD"},{ 100, "C"},{ 90, "XC"},{ 50, "L"},{ 40, "XL"},{ 10, "X"},{ 9, "IX"},{ 5, "V"},{ 4, "IV"},{ 1, "I"}}
We then take this and run it through a fold (called Aggregate in C#).
.Aggregate(
In the seed value to the Aggregate we create a transformation string of the "I"s equal to the value given by the caller.
t(1) = "I"
t(2) = "II"
t(3) = "III"
t(4) = "IIII"
...
t(20) = "IIIIIIIIIIIIIIIIIIII"
To do this we use the string constructor that takes a character and the number of times you wish that character to repeat.
new string('I', number),
We then have the lambda of the Aggregate in which we simply take the current Key and Value from the associative array and call Replace on the transformed string replacing the number of "I"s given in the Value with the Roman numeral given in the Key.
(m, _) => m.Replace(new string('I', _.Key), _.Value));
This is not the "best" implementation of the Roman Numeral kata, but it is a one liner!
"The one I'll slay; the other slayeth me."
-- Shakespeare, A Midsummer Night's Dream
