Roman to Integer - Practice Coding Problems

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

Understanding the Visualization

Input

Roman numeral string with symbols I,V,X,L,C,D,M

Process

Handle addition and subtraction rules

Output

Integer value of the Roman numeral

Key Takeaway

🎯 Key Insight: Process right-to-left comparing values - smaller before larger means subtraction

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
✓ 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	O(n)	O(1)	Check every adjacent pair for subtraction cases, then sum all values

Hash Map Right-to-Left — Algorithm Steps

Create hash map for Roman numeral values
Iterate from right to left
Compare current value with previous - subtract if smaller, add if larger

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Right

Begin from rightmost character

Compare Values

If current < previous, subtract; else add

Continue Left

Move left and repeat until done

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 prevValue = 0;
    int len = strlen(s);
    
    // Process from right to left
    for (int i = len - 1; i >= 0; i--) {
        int currentValue = getValue(s[i]);
        
        // If current value is smaller than previous, subtract it
        if (currentValue < prevValue) {
            result -= currentValue;
        } else {
            result += currentValue;
        }
        
        prevValue = currentValue;
    }
    
    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 O(1) hash map lookups

✓ Linear Growth

Space Complexity

O(1)

Hash map has fixed size of 7 entries, plus constant variables

✓ 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

Hash Map Right-to-Left — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler