> For the complete documentation index, see [llms.txt](https://ondrej-kvasnovsky-2.gitbook.io/algorithms/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ondrej-kvasnovsky-2.gitbook.io/algorithms/numbers/roman-to-integer.md).

# Roman to Integer

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, two is written as`II` in Roman numeral, just two one's added together. Twelve is written as,`XII`, which is simply`X`+`II`. The number twenty seven is written as`XXVII`, which is`XX`+`V`+`II`.

Roman numerals are usually written 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. Input is guaranteed to be within the range from 1 to 3999.

Here is a solution.

```
class Solution {
    private Map<Character, Integer> mapping = new HashMap<>();

    {
        mapping.put('I', 1);
        mapping.put('V', 5);
        mapping.put('X', 10);
        mapping.put('L', 50);
        mapping.put('C', 100);
        mapping.put('D', 500);
        mapping.put('M', 1000);
    }

    public int romanToInt(String s) {
        int result = 0;

        for (int i = 0; i < s.length(); i++) {
            char current = s.charAt(i);
            Integer currentValue = mapping.get(current);

            if (i < s.length() - 1) {
                char next = s.charAt(i + 1);
                Integer nextValue = mapping.get(next);
                if (nextValue > currentValue) {
                    currentValue = -currentValue;
                }
            }
            result += currentValue;
        }

        return result;
    }
}
```