---
# System prepended metadata

title: '[13. Roman to Integer](https://leetcode.com/problems/roman-to-integer/)'
tags: [Hash Table, easy, String, leetcode, Math]

---

###### tags: `leetcode` `easy` `Hash Table` `Math` `String`
# [13. Roman to Integer](https://leetcode.com/problems/roman-to-integer/)

## Description

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 ones 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 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.  

## Examples
### 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.  


## Constraints:

- $1 \leq s.length \leq 15$  
- `s` contains only the characters` ('I', 'V', 'X', 'L', 'C', 'D', 'M')`.  
- It is **guaranteed** that `s` is a valid roman numeral in the range `[1, 3999]`.  

## Code

```c=
int romanToInt(char* s) {
    int ans = 0, length = strlen(s);
    int* strArray = calloc(length, sizeof(int));
    for (int i = 0; i < length; i++) {
        switch (s[i]) {
            case 'I':
                strArray[i] = 1;
                break;

            case 'V':
                strArray[i] = 5;
                break;

            case 'X':
                strArray[i] = 10;
                break;

            case 'L':
                strArray[i] = 50;
                break;

            case 'C':
                strArray[i] = 100;
                break;

            case 'D':
                strArray[i] = 500;
                break;

            case 'M':
                strArray[i] = 1000;
                break;

            default:
                printf("Error input!\n");
                break;
        }
    }

    for (int i = 0; i < length; i++) {
        if (i != length - 1 && strArray[i] < strArray[i + 1]) {
            ans += strArray[i + 1] - strArray[i++];
        } else {
            ans += strArray[i];
        }
    }
    return ans;
}
```

## Complexity

|Space |Time  |
|-     |-     |
|$O(N)$|$O(N)$|

## Result

- Runtime: 15 ms, faster than 37.29%   
- Memory Usage: 5.8 MB, less than 53.70%  