Converting Decimal Number lying between 1 to 3999 to Roman Numerals

Given a number, find its corresponding Roman numeral.

Examples:

Input : 9
Output : IX

Input : 40
Output : XL

Input : 1904
Output : MCMIV

Following is the list of Roman symbols which include subtractive cases also:

SYMBOL VALUE
I 1
IV 4
V 5
IX 9
X 10
XL 40
L 50
XC 90
C 100
CD 400
D 500
CM 900
M 1000

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Idea is to convert the units, tens, hundreds, and thousands places of the given
number separately. If the digit is 0, then there’s no corresponding Roman numeral
symbol. The conversion of digit’s 4’s and 9’s are little bit different from other
digits because these digits follows subtractive notation.

Algorithm to convert decimal number to Roman Numeral

Compare given number with base values in the order 1000, 900, 500, 400, 100, 90,
50, 40, 10, 9, 5, 4, 1. Base value which is just smaller or equal to the given
number will be the initial base value (largest base value) .Divide the number by
its largest base value, the corresponding base symbol will be repeated quotient
times, the remainder will then become the number for future division and
repetitions.The process will be repeated until the number becomes zero.

Example to demonstrate above algorithm:

Convert 3549 to its Roman Numerals

Output:

MMMDXLIX

Explanation:
 Step 1
Initially number = 3549
Since 3549 >= 1000 ; largest base value will be 1000 initially.
Divide 3549/1000. Quotient = 3, Remainder =549. The corresponding symbol M will
be repeated thrice.

Step 2
Now, number = 549
1000 > 549 >= 500 ; largest base value will be 500.
Divide 549/500. Quotient = 1, Remainder =49. The corresponding symbol D will be
repeated once.

Step 3
Now, number = 49
50 > 49 >= 40 ; largest base value is 40.
Divide 49/40. Quotient = 1, Remainder = 9. The corresponding symbol XL will be
repeated once.

Step 4
Now, number = 9
10> 9 >= 9 ; largest base value is 9.
Divide 9/9. Quotient = 1, Remainder = 0. The corresponding symbol IX will be
repeated once.

Step 5

Finally number becomes 0, algorithm stops here.

Output obtained MMMDXLIX.

Following is the implementation of the above algorithm:

filter_none

edit

play_arrow

brightness_4
// C++ Program to convert decimal number to
// roman numerals
#include <bits/stdc++.h>
using namespace std;

// Function to convert decimal to Roman Numerals

int printRoman(int number)
{
int num[] = {1,4,5,9,10,40,50,90,100,400,500,900,1000};
string sym[] = {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
int i=12;
while(number>0)
{
int div = number/num[i];
number = number%num[i];
while(div--)
{
cout<<sym[i];
}
i--;
}
}

//Driver program
int main()
{
int number = 3549;

printRoman(number);

return 0;
}

Output:

Roman numeral is: MMMDXLIX

References : http://blog.functionalfun.net/2009/01/project-euler-89-converting-to-
and-from.html

Another Approach 1::

In this approach we have to first observe the problem. The number given in problem
statement can be maximum of 4 digits. The idea to solve this problem is:

Divide the given number into digits at different places like one’s , two’s ,
hundred’s or thousand’s.
Starting from the thousand’s place print the corresponding roman value. For
example, if the digit at thousand’s place is 3 then print the roman equivalent of
3000.
Repeat the second step until we reach one’s place.

Example:
Suppose the input number is 3549. So, starting from thousand’s place we will start
printing the roman equivalent. In this case we will print in the order as given
below:
First: Roman equivalent of 3000
Second: Roman equivalent of 500
Third: Roman equivalent of 40
Fourth: Roman equivalent of 9
So, the output will be: MMMDXLIX

Below is the the implementation of above idea.

filter_none

edit

play_arrow

brightness_4
// C++ Program for above approach
#include <bits/stdc++.h>
using namespace std;

// Function to calculate roman equivalent

string intToRoman(int num)
{
// storing roman values of digits from 0-9
// when placed at different places
string m[] = {"", "M", "MM", "MMM"};
 string c[] = {"", "C", "CC", "CCC", "CD", "D",
"DC", "DCC", "DCCC", "CM"};
string x[] = {"", "X", "XX", "XXX", "XL", "L",
"LX", "LXX", "LXXX", "XC"};
string i[] = {"", "I", "II", "III", "IV", "V",
"VI", "VII", "VIII", "IX"};

// Converting to roman
string thousands = m[num/1000];
string hundereds = c[(num%1000)/100];
string tens = x[(num%100)/10];
string ones = i[num%10];

string ans = thousands + hundereds + tens + ones;

return ans;
}

// Driver program to test above function

int main()
{
int number = 3549;
cout << intToRoman(number);
return 0;
}

Output:

MMMDXLIX

Thanks to Shashwat Jain for providing the above solution approach.

Another Approach 2::

In this approach we consider the main significant digit in the number. Ex: in 1234,
main significant digit is 1. Similarly in 345 it is 3.
In order to extract main significant digit out, we need to maintain a divisor (lets
call it div) like 1000 for 1234 (since 1234 / 1000 = 1) and 100 for 345 (345 / 100
= 3).

Also, lets maintain a dictionary called romanNumeral = {1 : ‘I’, 5: ‘V’, 10: ‘X’,
50: ‘L’, 100: ‘C’, 500: ‘D’, 1000: ‘M’}

Following is the algorithm:

if main significant digit <= 3

romanNumeral[div] * mainSignificantDigit

if main significant digit == 4

romanNumeral[div] + romanNumeral[div * 5]

if 5 <= main significant digit <= 8

romanNumeral[div * 5] + (romanNumeral[div] * ( mainSignificantDigit-5))

if main significant digit == 9

romanNumeral[div] + romanNumeral[div*10]

Example:
Suppose the input number is 3649.
 Iter 1
Initially number = 3649
main significant digit is 3. Div = 1000.
So, romanNumeral[1000] * 3
gives: MMM

Iter 2
now, number = 649
main significant digit is 6. Div = 100.
So romanNumeral[100*5] + (romanNumeral[div] * ( 6-5))
gives: DC

Iter 3
now, number = 49
main significant digit is 4. Div = 10.
So romanNumeral[10] + romanNumeral[10 * 5]
gives: XL

Iter 4
now, number = 9
main significant digit is 9. Div = 1.
So romanNumeral[1] * romanNumeral[1*10]
gives: IX

Final result by clubbing all the above: MMMDCXLIX

Below is the Python implementation of above idea.

`:wq