# Converting decimal numbers to Roman Numerals in C#

I decided to create a little project to implement converting decimal numbers to Roman Numerals in C#. You can solve this problem in quite a few different ways, I wanted to talk through the pattern based approach that I went for.

The Roman Numerals from 0 to 9 are as follows:

• 0 = “” (empty string)
• 1 = I
• 2 = II
• 3 = III
• 4 = IV
• 5 = V
• 6 = VI
• 7 = VII
• 8 = VIII
• 9 = IX

To start the project I wrote a set of tests that checked these first 10 cases. I like taking this approach as it allows you to solve for the simple base case, then you can refactor your solution to be more generic. Our first implementation that solves for the first ten numbers is:

```public static string ToRomanNumeral(this int integer)
{

var mapping = new Dictionary<int, string>
{
{0, ""},
{1, "I"},
{2, "II"},
{3, "III"},
{4, "IV"},
{5, "V"},
{6, "VI"},
{7, "VII"},
{8, "VIII"},
{9, "IX"},
};

return mapping[integer];
}
```

Obviously there is no error checking etc we are just solving for the 10 first cases. I decided to implement the method as an extension method on int as it makes the code look neat as it will allow you to write:

```    var romanNumeral = 9.ToRomanNumeral();
```

The next step is to look at the Roman Numerals up to 100 and see if we can spot any patterns. We don’t want to have to manually type out a dictionary for every Roman Numeral! If we look at the Roman Numeral representation for the tens column from 0 to 100 we find they are:

• 0 = “” (empty string)
• 10 = X
• 20 = XX
• 30 = XXX
• 40 = XL
• 50 = L
• 60 = LX
• 70 = LXX
• 80 = LXXX
• 90 = XC

We can straight away see that it is exactly the same as the numbers from 0 to 9 except you replace I with X, V with L and X with C. So lets pull that pattern out into something that can create a mapping dictionary given the 3 symbols. Doing this gives you the following method:

```private static Dictionary<int, string> CreateMapping(string baseSymbol, string midSymbol, string upperSymbol)
{
return new Dictionary<int, string>
{
{0, ""},
{1, baseSymbol},
{2, baseSymbol + baseSymbol},
{3, baseSymbol + baseSymbol + baseSymbol},
{4, baseSymbol + midSymbol},
{5, midSymbol},
{6, midSymbol + baseSymbol},
{7, midSymbol + baseSymbol + baseSymbol},
{8, midSymbol + baseSymbol + baseSymbol + baseSymbol},
{9, baseSymbol + upperSymbol},
};
}
```

We can now call the above method with the symbols for the column we want to calculate passing in the correct symbols. So for the units column we would write:

```    var unitMapping = CreateMapping("I", "V", "X");
```

Now we have this we it is straight forward to create the mapping for the hundreds column. To complete our implementation we want to add some error checks as we are only going to support Roman Numerals from 0 to 4000. The full solution is now quite trivial. We simply check the input is in our valid range (between 0 and 4000). Then we loop through each column looking up the symbol for that column in our mapping dictionary that we generate using our function above. Then we simply concatenate the symbols together using a StringBuilder and return the result.

The full solution with all of the tests is available on my GitHub repository: https://github.com/kevholditch/RomanNumerals.