How do you approach Roman to Integer?

Create a mapping of Roman symbols to their integer values.

What is the time complexity of Roman to Integer?

Time complexity: O(n). Space complexity: O(1).

What are common mistakes on Roman to Integer?

Overflowing at an intermediate step even though the final answer fits. Assuming a modulo is non-negative. In most languages -1 % n is negative, which breaks cyclic indexing. Testing floating-point values for exact equality where integer arithmetic would have been exact.

gitGood.dev

← Back to problems

Roman to Integer

EasyAlgorithms

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.

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 <= s.length <= 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].

Roman to Integer: approach, complexity and pitfalls

An easy math problem, graded against 7 test cases (4 of them hidden).

The pattern: Math

Number theory, digit manipulation, and closed-form reasoning.

Reach for it when you see: Primes, digits, base conversion, or a problem with a formula hiding behind it.

More Mathproblems →

If you are stuck

Show the 3-step hint ladder

Create a mapping of Roman symbols to their integer values.
If a smaller value appears before a larger value, subtract it.
Otherwise, add the value to the total.

The optimal approach

Show the approach: Left to Right Pass

Iterate through the string. If the current value is less than the next value, subtract it; otherwise, add it.

Time: O(n)
Space: O(1)

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

Common Math mistakes

These apply to the pattern as a whole, not just this problem.

Overflowing at an intermediate step even though the final answer fits.
Assuming a modulo is non-negative. In most languages `-1 % n` is negative, which breaks cyclic indexing.
Testing floating-point values for exact equality where integer arithmetic would have been exact.