Integer to Roman - Practice Coding Problems

Integer to Roman - Problem

Convert Integer to Roman Numerals

Roman numerals are an ancient number system that's still used today - from clock faces to movie sequels! Your task is to convert a modern integer into its ancient Roman numeral equivalent.

The Roman numeral system uses seven symbols:

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

Special Rules:

Generally, symbols are combined from largest to smallest (left to right)
When a smaller numeral appears before a larger one, it means subtraction
Only specific subtractive combinations are allowed: IV (4), IX (9), XL (40), XC (90), CD (400), CM (900)
You can't repeat a symbol more than 3 times consecutively

Examples: 3 → III, 4 → IV, 9 → IX, 58 → LVIII, 1994 → MCMXCIV

Input & Output

example_1.py — Basic Conversion

$ Input: num = 3

› Output: "III"

💡 Note: 3 is represented as three I's in Roman numerals: I + I + I = III

example_2.py — Subtractive Case

$ Input: num = 58

› Output: "LVIII"

💡 Note: 58 = 50 + 5 + 3 = L + V + III = LVIII

example_3.py — Complex Number

$ Input: num = 1994

› Output: "MCMXCIV"

💡 Note: 1994 = 1000 + 900 + 90 + 4 = M + CM + XC + IV = MCMXCIV (uses multiple subtractive forms)

Constraints

1 ≤ num ≤ 3999
Input is guaranteed to be a valid integer
Note: Roman numerals don't have a symbol for zero

Visualization

Tap to expand

Understanding the Visualization

Prepare Coin Types

Set up Roman 'coins' including special subtractive combinations (IV=4, IX=9, etc.)

Start with Largest

Always try to use the largest possible Roman value first

Calculate Quantity

Use division to find how many of each 'coin' type to use

Update Remainder

Use modulo to find what's left after using current coin type

Repeat Process

Continue with next largest coin type until remainder is zero

Key Takeaway

🎯 Key Insight: Pre-computing all valid Roman combinations (including subtractive forms) and processing them in descending order allows for an elegant greedy algorithm that builds the optimal Roman numeral representation in a single pass.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a pre-computed lookup table containing all Roman numeral values and their symbols (including subtractive forms like IV, IX, XL, XC, CD, CM) in descending order. We iterate through this table once, using division and modulo operations to efficiently determine how many times each symbol should be used, achieving O(1) time complexity with clean, readable code.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated Subtraction)	O(1)	O(1)	Repeatedly subtract the largest possible Roman numeral value and build the result
Optimized Lookup Table (Optimal)	O(1)	O(1)	Use pre-computed mapping of all Roman numeral patterns for direct lookup

Brute Force (Repeated Subtraction) — Algorithm Steps

Create arrays for all Roman symbols and their values
For each Roman value from largest to smallest:
While the input is greater than or equal to current value:
Subtract the value and append the symbol
Continue until input becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Input

Begin with the input number (e.g., 1994)

Find Largest Value

Find the largest Roman value ≤ input (M = 1000)

Subtract and Append

Subtract 1000, append 'M', remainder = 994

Continue Process

Next largest: CM = 900, remainder = 94

Final Steps

XC = 90, remainder = 4, then IV = 4, done!

Code -

solution.c — C

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

char* intToRoman(int num) {
    int values[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
    char* symbols[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
    char* result = malloc(20 * sizeof(char));
    result[0] = '\0';
    
    for (int i = 0; i < 13; i++) {
        while (num >= values[i]) {
            strcat(result, symbols[i]);
            num -= values[i];
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Maximum 13 iterations for any input (since max input is 3999 and we have predefined symbol mappings)

✓ Linear Growth

Space Complexity

O(1)

Only using fixed-size arrays for symbols and values

✓ Linear Space

89.5K Views

Medium-High Frequency

~15 min Avg. Time

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

Convert Integer to Roman Numerals

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Repeated Subtraction) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler