Roman to Integer

Roman to Integer - 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

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 string s, convert it to an integer.

Input & Output

Example 1 — Basic Roman Numeral

$ Input: s = "III"

› Output: 3

💡 Note: III = 3 (simple addition: 1 + 1 + 1 = 3)

Example 2 — Subtraction Case

$ Input: s = "IV"

› Output: 4

💡 Note: IV = 4 (subtraction case: I before V means 5 - 1 = 4)

Example 3 — Mixed Operations

$ Input: s = "MCMXC"

› Output: 1990

💡 Note: M = 1000, CM = 900 (1000-100), XC = 90 (100-10), so 1000 + 900 + 90 = 1990

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]

Visualization

Tap to expand

Asked in

f Facebook 35 a Amazon 28 M Microsoft 22 G Google 18

The key insight is to process the Roman numeral from right to left, comparing each character's value with the previous one. If the current value is smaller, it's part of a subtraction pair (like IV = 4). Best approach uses a hash map for O(1) lookups. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Check Each Pair	O(n)	O(1)	Check every adjacent pair for subtraction cases, then sum all values
Hash Map Right-to-Left	O(n)	O(1)	Process string from right to left, comparing current value with previous

Brute Force Check Each Pair — Algorithm Steps

Iterate through string checking each position
If current and next form subtraction pair, handle specially
Otherwise add individual character value

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Pairs

Look at each character and next character

Handle Subtraction

If pair forms subtraction case, compute difference

Sum Values

Add all values to get final result

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int getValue(char c) {
    switch(c) {
        case 'I': return 1;
        case 'V': return 5;
        case 'X': return 10;
        case 'L': return 50;
        case 'C': return 100;
        case 'D': return 500;
        case 'M': return 1000;
        default: return 0;
    }
}

int solution(char* s) {
    int result = 0;
    int i = 0;
    int len = strlen(s);
    
    while (i < len) {
        // Check if current character forms subtraction pair
        if (i + 1 < len) {
            char curr = s[i];
            char next = s[i + 1];
            
            if ((curr == 'I' && (next == 'V' || next == 'X')) ||
                (curr == 'X' && (next == 'L' || next == 'C')) ||
                (curr == 'C' && (next == 'D' || next == 'M'))) {
                result += getValue(next) - getValue(curr);
                i += 2;
                continue;
            }
        }
        
        // Normal case: add current character value
        result += getValue(s[i]);
        i++;
    }
    
    return result;
}

int main() {
    char s[20];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with constant work per character

✓ Linear Growth

Space Complexity

O(1)

Only using variables for sum and temporary values

✓ Linear Space

219.7K Views

High Frequency

~15 min Avg. Time

8.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Check Each Pair — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler