Integer to Roman

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```

For example, `2` is written as `II` in Roman numeral, just two one’s added together. `12` is written as `XII`, which is simply `X + II`. The number `27` is written as `XXVII`, which is `XX + V + II`.

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 an integer, convert it to a roman numeral.

Example 1:

```Input: num = 3
Output: "III"
Explanation: 3 is represented as 3 ones.
```

Example 2:

```Input: num = 58
Output: "LVIII"
Explanation: L = 50, V = 5, III = 3.
```

Example 3:

```Input: num = 1994
Output: "MCMXCIV"
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
```

Constraints:

• `1 <= num <= 3999`

Solution:

``````def intToRoman(self, num: int) -> str:
symbols = ['I', 'V', 'X', 'L', 'C', 'D', 'M']
level = 0
roman_num = ''
while num:
remainder = num % 10
num = num // 10

if remainder == 0:
pass
elif remainder in [1,2,3]:
roman_num = symbols[level] * remainder + roman_num
elif remainder == 4:
roman_num = symbols[level] + symbols[level+1] + roman_num
elif remainder in [5,6,7,8]:
roman_num = symbols[level+1] + (remainder-5) * symbols[level] + roman_num
elif remainder == 9:
roman_num = symbols[level] + symbols[level+2] + roman_num

level += 2

return roman_num``````

Solution 2:

``````class Solution:
def intToRoman(self, num: int) -> str:
Dict={1:'I',4:'IV',5:'V', 9:'IX',10:'X',40:'XL',50:'L',90:'XC',100:'C',400:'CD',500:'D',900:'CM',1000:'M'}
output=''
while num:
keys=list(Dict.keys())
l=bisect.bisect_right(keys,num)
output=output+Dict[keys[l-1]]
num=num-keys[l-1]
return output``````

Solution 3 – Recursion:

``````class Solution:
def __init__(self):
self.symbol_table = [('M',1000),('CM',900),('D',500),('CD',400),('C',100),('XC',90),('L',50),('XL',40),('X',10),('IX',9),('V',5),('IV',4),('I',1)]

def intToRoman(self, num: int) -> str:

if num == 0:
return ""

for index,symbol in enumerate(self.symbol_table) :
#If modulo by the roman symbol is zero its bigger than num, try next symbol
if num%symbol[1] == num :
continue
#This is the biggest symbol which divides num into at least one part
if num%symbol[1] < num :
#How many symbols do we need?
factor = num // symbol[1]
#Index of this symbol in symbol table
x=index
break

roman=self.symbol_table[x][0]
roman_int_val=self.symbol_table[x][1]

return roman*factor + self.intToRoman(num - factor*roman_int_val)``````