## Introduction

Let's solve the leetcode's problem number 13. Roman to Integer.

This problem is pretty straightforward. You will take the roman number as an input and you have to return a respective integer number.

While I was solving the problem there was one test case that failed multiple times. So I decided to take that as an example, this is the roman number "MCMXCIV" which converts back to 1994 in numbers.

Read the problem in detail here.

But here is the snapshot of the problem,

Roman numerals are represented by seven different symbols: I, V, X, L, C, D, and M.

Symbol Value

I 1

V 5

X 10

L 50

C 100

D 500

M 1000

For example, 2 is written as II in Roman numeral, just two one's added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

Roman numerals are usually written from largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used,

- I can be placed before V (5) and X (10) to make 4 and 9.
- X can be placed before L (50) and C (100) to make 40 and 90.
- C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer.

**Example 1**

Input: s = "III"

Output: 3

Explanation: III = 3.

**Example 2**

Input: s = "LVIII"

Output: 58

Explanation: L = 50, V= 5, III = 3.

**Example 3**

Input: s = "MCMXCIV"

Output: 1994

Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

## Logic

Before we actually start coding let's discuss some logic beforehand.

So we need a data structure to store the roman number to its respective integer number. Such as for 'I' we need 1, for 'V' we would map 5.

As we are using C#, we just have the right data structure to store key value pairs. Yes, we are going to use the dictionary.

```
Dictionary < char, int > romanNumbersDictionary = new() {
{
'I',
1
}, {
'V',
5
}, {
'X',
10
}, {
'L',
50
}, {
'C',
100
}, {
'D',
500
}, {
'M',
1000
}
};
```

Now comes the logic,

Here all we gotta do is either subtraction or addition.

- For example, if string is "III" then we would do 1+1+1 = 3
- If string is "IV" then we would compare for current and its next element. If the next element's numeric value is greater than the current element's value, we would subtract else we add.
- I = 1, V= 5: Here V > I so we substract, 1 - 5 = -4
- then in for the last element just add the respective value so V = 5 to the equation -4 + 5 = 4

That's all. That's your whole and soul logic.

Now for our example, I have created a flow chart just for you. With the flow chart you'll get a slight idea how our logic is going to work with every iteration, and then repeat the steps for all the elements in the string.

**Note**

While comparing the next element we would encounter an Array IndexOutofBoundsException when we reach the last element. that is because we have exhausted the array length. for ith element we don't have i+1 element. So we need to add that validation as well.

- Just as an example of "IV" when a pointer reaches V we would simply add the value of "V" and exit the loop. I know this would be confusing. That is exactly why I have created this beautiful flowchart.

Figure 1: Flowchart Roman to Nmber

Code is pretty straight forward too,

```
namespace RomanToNumbersAndReverse
{
internal class RomanToNumber
{
public int RomanToInt(string s)
{
int sum = 0;
Dictionary<char, int> romanNumbersDictionary = new()
{
{ 'I', 1 },
{ 'V', 5 },
{ 'X', 10 },
{ 'L', 50 },
{ 'C', 100 },
{ 'D', 500 },
{ 'M', 1000 }
};
for (int i = 0; i < s.Length; i++)
{
char currentRomanChar = s[i];
romanNumbersDictionary.TryGetValue(currentRomanChar, out int num);
if (i + 1 < s.Length && romanNumbersDictionary[s[i + 1]] > romanNumbersDictionary[currentRomanChar])
{
sum -= num;
}
else
{
sum += num;
}
}
return sum;
}
}
}
```

Listing 1: RomanToNumber.cs

Figure 2: Code snippet in listing 1 runs against all the test cases in LeetCode