Convert an integer from 1 to 3999 into its Roman numeral representation. Test your code, then compare with the explained solution. Free online practice.

Integer to Roman

Reverse Integer

Koko Eating Bananas

Convert an integer from 1 to 3999 into its Roman numeral representation.

Roman numerals are written with seven symbols: `I` (1), `V` (5), `X` (10), `L` (50), `C` (100), `D` (500), and `M` (1000).

Numbers are generally written largest symbol first. The exception is six subtractive cases, where a smaller symbol precedes a larger one to mean subtraction:
- `IV` = 4 and `IX` = 9
- `XL` = 40 and `XC` = 90
- `CD` = 400 and `CM` = 900

Given an integer `num`, convert it to a Roman numeral string.

**Input / output**
- Input: `num: int`
- Output: `string` — the Roman numeral

## Examples
```
Input: {"num":3}
Output: "III"
```

```
Input: {"num":58}
Output: "LVIII"
```

```
Input: {"num":1994}
Output: "MCMXCIV"
```

## Constraints
- `1 <= num <= 3999`

## Follow-up
The thirteen value/symbol pairs (including the six subtractive ones) are chosen so a single greedy pass always produces the canonical numeral. Why does greedily subtracting the largest usable value never paint you into a corner?

- List the thirteen value/symbol pairs in descending order of value, with the six subtractive forms (`CM`, `CD`, `XC`, `XL`, `IX`, `IV`) interleaved at their exact values.
- Including the subtractive pairs directly in the table is what lets a plain greedy loop emit canonical numerals without special cases.

Model the symbol table

- Walk the table from largest value to smallest.
- While the remaining number is at least the current value, append that symbol and subtract the value.
- Move to the next pair when the current one no longer fits.

Greedily subtract

- Each ordinary symbol repeats at most three times before the next subtractive form takes over (e.g. `III` then `IV`), so the table encodes the "no four-in-a-row" rule implicitly.
- Taking the largest usable value can never force an invalid or longer representation, because the smaller values can always cover whatever remainder is left.

Why greedy is safe here

- Build the result string in one descending pass.
- Time is `O(1)` because the table size is fixed and the number is bounded by 3999; space is `O(1)` beyond the output.

Optimal greedy solution

- Forgetting the subtractive pairs and emitting `IIII` instead of `IV`.
- Using `if` instead of `while`, which stops after a single `M` when the number needs several.
- Listing the table out of order so a larger symbol is reachable after a smaller one was already applied.