Roman to Integer - Practice Coding Problems

Roman to Integer - Problem

Roman numerals are an ancient numbering system still used today on clock faces, building dates, and movie credits. Your task is to decode these historical symbols and convert them back to modern integers!

The seven Roman numeral symbols and their values are:

Symbol	Value
I	1
V	5
X	10
L	50
C	100
D	500
M	1000

Basic Addition Rule: Roman numerals are typically written from largest to smallest, left to right. For example: XII = 10 + 1 + 1 = 12

Subtraction Rule: However, there's a twist! To avoid writing four identical symbols in a row, Romans used a subtraction principle:

IV = 4 (5 - 1), not IIII
IX = 9 (10 - 1)
XL = 40 (50 - 10)
XC = 90 (100 - 10)
CD = 400 (500 - 100)
CM = 900 (1000 - 100)

Goal: Given a valid Roman numeral string, return its integer equivalent.

Input & Output

example_1.py — Basic Roman Numeral

$ Input: s = "III"

› Output: 3

💡 Note: III = 3. Simple addition of three I's: 1 + 1 + 1 = 3.

example_2.py — Subtraction Case

$ Input: s = "IV"

› Output: 4

💡 Note: IV = 4. This uses the subtraction rule: since I (1) comes before V (5), we subtract: 5 - 1 = 4.

example_3.py — Complex Roman Numeral

$ Input: s = "MCMXC"

› Output: 1990

💡 Note: MCMXC = 1990. Breaking it down: M (1000) + CM (900) + XC (90) = 1000 + 900 + 90 = 1990. Both CM and XC use subtraction rules.

Visualization

Tap to expand

Understanding the Visualization

Set Up Dictionary

Create a lookup table for each Roman symbol and its integer value

Read Left to Right

Process each character in the string from left to right

Look Ahead Rule

For each character, peek at the next character to determine add vs subtract

Apply Logic

If current < next: subtract current value. Otherwise: add current value

Sum Result

Continue until all characters are processed and return the final sum

Key Takeaway

🎯 Key Insight: The magic happens by looking ahead! When a smaller Roman numeral sits before a larger one, it signals subtraction. This one simple rule handles all special cases elegantly.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character is processed exactly once

✓ Linear Growth

Space Complexity

O(1)

Only using a fixed-size hash map (7 entries) and a few variables

✓ Linear Space

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]

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 24 Apple 18

The optimal solution uses a one-pass approach with a hash table. The key insight is that when a smaller Roman numeral appears before a larger one (like I before V), it represents subtraction. By comparing each character with the next character during a single pass, we can determine whether to add or subtract each character's value, achieving O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Pairs)	O(n²)	O(n)	Check every possible subtraction case explicitly with nested conditions
One-Pass Hash Table (Optimal)	O(n)	O(1)	Single pass through string, comparing each character with the next to decide add or subtract

Brute Force (Check All Pairs) — Algorithm Steps

Scan string for all subtraction pairs (IV, IX, XL, XC, CD, CM)
Replace found pairs with their values and mark positions as processed
Iterate through remaining characters and add their individual values
Sum all values to get final result

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Scan entire string looking for 'IV' pairs and mark them as processed

Second Pass

Scan entire string looking for 'IX' pairs and mark them as processed

Continue

Repeat for all 6 subtraction cases (XL, XC, CD, CM)

Final Pass

Add up all remaining unprocessed individual characters

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.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 romanToInt(char* s) {
    int len = strlen(s);
    bool processed[len];
    for(int i = 0; i < len; i++) processed[i] = false;
    
    int result = 0;
    char* patterns[] = {"IV", "IX", "XL", "XC", "CD", "CM"};
    int values[] = {4, 9, 40, 90, 400, 900};
    
    // Check for all subtraction cases
    for(int p = 0; p < 6; p++) {
        for(int i = 0; i <= len - 2; i++) {
            if(!processed[i] && !processed[i+1] && 
               s[i] == patterns[p][0] && s[i+1] == patterns[p][1]) {
                result += values[p];
                processed[i] = true;
                processed[i+1] = true;
            }
        }
    }
    
    // Process remaining single characters
    for(int i = 0; i < len; i++) {
        if(!processed[i]) {
            result += getValue(s[i]);
        }
    }
    
    return result;
}

int main() {
    char s[20];
    fgets(s, sizeof(s), stdin);
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if(start) {
        start++;
        char* end = strchr(start, '"');
        if(end) *end = '\0';
        printf("%d\n", romanToInt(start));
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple scans of the string to find and replace subtraction pairs, where each scan can be O(n)

⚠ Quadratic Growth

Space Complexity

O(n)

May need to create modified string or boolean array to track processed positions

⚡ Linearithmic Space

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]

256.8K Views

Very High Frequency

~12 min Avg. Time

8.4K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler