Dado un número, encuentre su número romano correspondiente.
Ejemplos:
Input : 9 Output : IX Input : 40 Output : XL Input : 1904 Output : MCMIV
La siguiente es la lista de símbolos romanos que también incluyen casos sustractivos:
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
La idea es convertir las unidades, decenas, centenas y miles del número dado por separado. Si el dígito es 0, entonces no hay ningún símbolo de número romano correspondiente. La conversión de dígitos 4 y 9 es un poco diferente de otros dígitos porque estos dígitos siguen la notación sustractiva .
Algoritmo para convertir números decimales a números romanos
Compara el número dado con valores base en el orden 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1. Valor base que es más pequeño o igual al número dado será el valor base inicial (valor base más grande). Divida el número por su valor base más grande, el símbolo base correspondiente se repetirá el cociente veces, el resto se convertirá en el número para futuras divisiones y repeticiones. El proceso se repetirá hasta que el número sea cero.
Ejemplo para demostrar el algoritmo anterior:
Convert 3549 to its Roman Numerals
Producción:
MMMDXLIX
Explicación:
Explicación:
Paso 1
- Número inicial = 3549
- Desde 3549 >= 1000 ; el valor base más grande será 1000 inicialmente.
- Divide 3549/1000. Cociente = 3, Resto =549. El símbolo M correspondiente se repetirá tres veces.
- Añadimos el valor del Resultado en la 2ª Lista.
- Ahora Resto no es igual a 0 por lo que llamamos a la función de nuevo.
Paso 2
- Ahora, número = 549
- 1000 > 549 >= 500 ; el valor base más grande será 500.
- Divide 549/500. Cociente = 1, Resto =49. El símbolo D correspondiente se repetirá una vez y detendrá el ciclo.
- Añadimos el valor del Resultado en la 2ª Lista.
- Ahora Resto no es igual a 0 por lo que llamamos a la función de nuevo.
Paso 3
- Ahora, número = 49
- 50 > 49 >= 40 ; el valor base más grande es 40.
- Divide 49/40. Cociente = 1, Resto = 9. El símbolo XL correspondiente se repetirá una vez y detendrá el ciclo.
- Añadimos el valor del Resultado en la 2ª Lista.
- Ahora Resto no es igual a 0 por lo que llamamos a la función de nuevo.
Paso 4
- Ahora, número = 9
- El número 9 está presente en la lista ls, por lo que obtenemos directamente el valor del dictado del diccionario y establecemos Remainder=0 y detenemos el ciclo.
- Resto = 0. El símbolo IX correspondiente se repetirá una vez y ahora el valor del resto es 0, por lo que no volveremos a llamar a la función.
Paso 5
- Finalmente, unimos la 2ª lista de valores.
- La salida obtenida MMMDXLIX.
A continuación se muestra la implementación del algoritmo anterior:
C++
// 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;
}
Java
// Java Program to convert decimal number to
// roman numerals
class GFG {
// To add corresponding base symbols in the array
// to handle cases that follow subtractive notation.
// Base symbols are added index 'i'.
static int sub_digit(char num1, char num2, int i, char[] c) {
c[i++] = num1;
c[i++] = num2;
return i;
}
// To add symbol 'ch' n times after index i in c[]
static int digit(char ch, int n, int i, char[] c) {
for (int j = 0; j < n; j++) {
c[i++] = ch;
}
return i;
}
// Function to convert decimal to Roman Numerals
static void printRoman(int number) {
char c[] = new char[10001];
int i = 0;
// If number entered is not valid
if (number <= 0) {
System.out.printf("Invalid number");
return;
}
// TO convert decimal number to roman numerals
while (number != 0) {
// If base value of number is greater than 1000
if (number >= 1000) {
// Add 'M' number/1000 times after index i
i = digit('M', number / 1000, i, c);
number = number % 1000;
} // If base value of number is greater than or
// equal to 500
else if (number >= 500) {
// To add base symbol to the character array
if (number < 900) {
// Add 'D' number/1000 times after index i
i = digit('D', number / 500, i, c);
number = number % 500;
} // To handle subtractive notation in case of number
// having digit as 9 and adding corresponding base
// symbol
else {
// Add C and M after index i/.
i = sub_digit('C', 'M', i, c);
number = number % 100;
}
} // If base value of number is greater than or equal to 100
else if (number >= 100) {
// To add base symbol to the character array
if (number < 400) {
i = digit('C', number / 100, i, c);
number = number % 100;
} // To handle subtractive notation in case of number
// having digit as 4 and adding corresponding base
// symbol
else {
i = sub_digit('C', 'D', i, c);
number = number % 100;
}
} // If base value of number is greater than or equal to 50
else if (number >= 50) {
// To add base symbol to the character array
if (number < 90) {
i = digit('L', number / 50, i, c);
number = number % 50;
} // To handle subtractive notation in case of number
// having digit as 9 and adding corresponding base
// symbol
else {
i = sub_digit('X', 'C', i, c);
number = number % 10;
}
} // If base value of number is greater than or equal to 10
else if (number >= 10) {
// To add base symbol to the character array
if (number < 40) {
i = digit('X', number / 10, i, c);
number = number % 10;
} // To handle subtractive notation in case of
// number having digit as 4 and adding
// corresponding base symbol
else {
i = sub_digit('X', 'L', i, c);
number = number % 10;
}
} // If base value of number is greater than or equal to 5
else if (number >= 5) {
if (number < 9) {
i = digit('V', number / 5, i, c);
number = number % 5;
} // To handle subtractive notation in case of number
// having digit as 9 and adding corresponding base
// symbol
else {
i = sub_digit('I', 'X', i, c);
number = 0;
}
} // If base value of number is greater than or equal to 1
else if (number >= 1) {
if (number < 4) {
i = digit('I', number, i, c);
number = 0;
} // To handle subtractive notation in case of
// number having digit as 4 and adding corresponding
// base symbol
else {
i = sub_digit('I', 'V', i, c);
number = 0;
}
}
}
// Printing equivalent Roman Numeral
System.out.printf("Roman numeral is: ");
for (int j = 0; j < i; j++) {
System.out.printf("%c", c[j]);
}
}
//Driver program
public static void main(String[] args) {
int number = 3549;
printRoman(number);
}
}
// This code is contributed by PrinciRaj1992
Python3
# Python3 program to convert
# decimal number to roman numerals
ls=[1000,900,500,400,100,90,50,40,10,9,5,4,1]
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"}
ls2=[]
# Function to convert decimal to Roman Numerals
def func(no,res):
for i in range(0,len(ls)):
if no in ls:
res=dict[no]
rem=0
break
if ls[i]<no:
quo=no//ls[i]
rem=no%ls[i]
res=res+dict[ls[i]]*quo
break
ls2.append(res)
if rem==0:
pass
else:
func(rem,"")
# Driver code
if __name__ == "__main__":
func(3549, "")
print("".join(ls2))
# This code is contributed by
# VIKAS CHOUDHARY(vikaschoudhary344)
C#
// C# Program to convert decimal number
// to roman numerals
using System;
class GFG
{
// To add corresponding base symbols in the
// array to handle cases which follow subtractive
// notation. Base symbols are added index 'i'.
static int sub_digit(char num1, char num2,
int i, char[] c)
{
c[i++] = num1;
c[i++] = num2;
return i;
}
// To add symbol 'ch' n times after index i in c[]
static int digit(char ch, int n, int i, char[] c)
{
for (int j = 0; j < n; j++)
{
c[i++] = ch;
}
return i;
}
// Function to convert decimal to Roman Numerals
static void printRoman(int number)
{
char[] c = new char[10001];
int i = 0;
// If number entered is not valid
if (number <= 0)
{
Console.WriteLine("Invalid number");
return;
}
// TO convert decimal number to
// roman numerals
while (number != 0)
{
// If base value of number is
// greater than 1000
if (number >= 1000)
{
// Add 'M' number/1000 times after index i
i = digit('M', number / 1000, i, c);
number = number % 1000;
}
// If base value of number is greater
// than or equal to 500
else if (number >= 500)
{
// To add base symbol to the character array
if (number < 900)
{
// Add 'D' number/1000 times after index i
i = digit('D', number / 500, i, c);
number = number % 500;
}
// To handle subtractive notation in case
// of number having digit as 9 and adding
// corresponding base symbol
else
{
// Add C and M after index i/.
i = sub_digit('C', 'M', i, c);
number = number % 100;
}
}
// If base value of number is greater
// than or equal to 100
else if (number >= 100)
{
// To add base symbol to the character array
if (number < 400)
{
i = digit('C', number / 100, i, c);
number = number % 100;
}
// To handle subtractive notation in case
// of number having digit as 4 and adding
// corresponding base symbol
else
{
i = sub_digit('C', 'D', i, c);
number = number % 100;
}
}
// If base value of number is greater
// than or equal to 50
else if (number >= 50)
{
// To add base symbol to the character array
if (number < 90)
{
i = digit('L', number / 50, i, c);
number = number % 50;
}
// To handle subtractive notation in case
// of number having digit as 9 and adding
// corresponding base symbol
else
{
i = sub_digit('X', 'C', i, c);
number = number % 10;
}
}
// If base value of number is greater
// than or equal to 10
else if (number >= 10)
{
// To add base symbol to the character array
if (number < 40)
{
i = digit('X', number / 10, i, c);
number = number % 10;
}
// To handle subtractive notation in case of
// number having digit as 4 and adding
// corresponding base symbol
else
{
i = sub_digit('X', 'L', i, c);
number = number % 10;
}
}
// If base value of number is greater
// than or equal to 5
else if (number >= 5)
{
if (number < 9)
{
i = digit('V', number / 5, i, c);
number = number % 5;
}
// To handle subtractive notation in case
// of number having digit as 9 and adding
// corresponding base symbol
else
{
i = sub_digit('I', 'X', i, c);
number = 0;
}
}
// If base value of number is greater
// than or equal to 1
else if (number >= 1)
{
if (number < 4)
{
i = digit('I', number, i, c);
number = 0;
}
// To handle subtractive notation in
// case of number having digit as 4
// and adding corresponding base symbol
else
{
i = sub_digit('I', 'V', i, c);
number = 0;
}
}
}
// Printing equivalent Roman Numeral
Console.WriteLine("Roman numeral is: ");
for (int j = 0; j < i; j++)
{
Console.Write("{0}", c[j]);
}
}
// Driver Code
public static void Main()
{
int number = 3549;
printRoman(number);
}
}
// This code is contributed by Rajput-Ji
Javascript
<script>
// JavaScript Program to convert decimal number to
// roman numerals
// Function to convert decimal to Roman Numerals
function printRoman(number)
{
let num = [1,4,5,9,10,40,50,90,100,400,500,900,1000];
let sym = ["I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"];
let i=12;
while(number>0)
{
let div = Math.floor(number/num[i]);
number = number%num[i];
while(div--)
{
document.write(sym[i]);
}
i--;
}
}
//Driver program
let number = 3549;
printRoman(number);
//This code is contributed by Manoj
</script>
Producción
MMMDXLIX
Referencias: http://blog.functionfun.net/2009/01/project-euler-89-converting-to-and-from.html
Otro enfoque 1: En
este enfoque, primero tenemos que observar el problema. El número dado en el enunciado del problema puede tener un máximo de 4 dígitos. La idea para resolver este problema es:
- Divide el número dado en dígitos en diferentes lugares como uno, dos, cien o mil.
- A partir del lugar de las mil imprima el valor romano correspondiente. Por ejemplo, si el dígito en el lugar de mil es 3, imprima el equivalente romano de 3000.
- Repetir el segundo paso hasta llegar al lugar de uno.
Ejemplo :
supongamos que el número de entrada es 3549. Entonces, comenzando desde el lugar de mil, comenzaremos a imprimir el equivalente romano. En este caso, imprimiremos en el orden que se indica a continuación:
Primero : equivalente romano de 3000
Segundo : equivalente romano de 500
Tercero : equivalente romano de 40
Cuarto : equivalente romano de 9
Entonces, la salida será: MMMDXLIX
A continuación se muestra la implementación de la idea anterior.
C++
// 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 hundreds = c[(num % 1000) / 100];
string tens = x[(num % 100) / 10];
string ones = i[num % 10];
string ans = thousands + hundreds + tens + ones;
return ans;
}
// Driver program to test above function
int main()
{
int number = 3549;
cout << intToRoman(number);
return 0;
}
Java
// Java Program for above approach
class GFG {
// Function to calculate roman equivalent
static 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 hundreds = c[(num % 1000) / 100];
String tens = x[(num % 100) / 10];
String ones = i[num % 10];
String ans = thousands + hundreds + tens + ones;
return ans;
}
// Driver program to test above function
public static void main(String[] args)
{
int number = 3549;
System.out.println(intToRoman(number));
}
}
Python3
# Python3 program for above approach # Function to calculate roman equivalent def intToRoman(num): # Storing roman values of digits from 0-9 # when placed at different places m = ["", "M", "MM", "MMM"] c = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM "] x = ["", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"] i = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"] # Converting to roman thousands = m[num // 1000] hundreds = c[(num % 1000) // 100] tens = x[(num % 100) // 10] ones = i[num % 10] ans = (thousands + hundreds + tens + ones) return ans # Driver code if __name__ == "__main__": number = 3549 print(intToRoman(number)) # This code is contributed by rutvik_56
C#
// C# Program for above approach
using System;
class GFG {
// Function to calculate roman equivalent
static 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 hundreds = c[(num % 1000) / 100];
String tens = x[(num % 100) / 10];
String ones = i[num % 10];
String ans = thousands + hundreds + tens + ones;
return ans;
}
// Driver program to test above function
public static void Main()
{
int number = 3549;
Console.WriteLine(intToRoman(number));
}
}
PHP
<?php
// PHP Program for above approach
// Function to calculate roman equivalent
function intToRoman($num)
{
// storing roman values of digits from 0-9
// when placed at different places
$m = array("", "M", "MM", "MMM");
$c = array("", "C", "CC", "CCC", "CD", "D",
"DC", "DCC", "DCCC", "CM");
$x = array("", "X", "XX", "XXX", "XL", "L",
"LX", "LXX", "LXXX", "XC");
$i = array("", "I", "II", "III", "IV", "V",
"VI", "VII", "VIII", "IX");
// Converting to roman
$thousands = $m[$num / 1000];
$hundreds = $c[($num % 1000) / 100];
$tens = $x[($num % 100) / 10];
$ones = $i[$num % 10];
$ans = $thousands . $hundreds . $tens . $ones;
return $ans;
}
// Driver Code
$number = 3549;
echo intToRoman($number);
// This code is contributed by Akanksha Rai
Javascript
<script>
// JavaScript Program for above approach
// Function to calculate roman equivalent
function intToRoman(num)
{
// storing roman values of digits from 0-9
// when placed at different places
let m = ["", "M", "MM", "MMM"];
let c = ["", "C", "CC", "CCC", "CD", "D",
"DC", "DCC", "DCCC", "CM"];
let x = ["", "X", "XX", "XXX", "XL", "L",
"LX", "LXX", "LXXX", "XC"];
let i = ["", "I", "II", "III", "IV", "V",
"VI", "VII", "VIII", "IX"];
// Converting to roman
let a1 = Math.floor(num/1000);
let a2 = Math.floor((num%1000)/100);
let a3 = Math.floor((num%100)/10);
let thousands = m[a1];
let hundreds = c[a2];
let tens = x[a3];
let ones = i[num%10];
let ans = thousands + hundreds + tens + ones;
return ans;
}
// Driver program to test above function
let number = 3549;
document.write(intToRoman(number));
//This code is contributed by Mayank Tyagi
</script>
Producción
MMMDXLIX
Gracias a Shashwat Jain por proporcionar el enfoque de solución anterior.
Otro enfoque 2: En
este enfoque consideramos el principal dígito significativo en el número. Ej: en 1234, el dígito significativo principal es 1. De manera similar, en 345 es 3.
Para extraer el dígito significativo principal, necesitamos mantener un divisor (llamémoslo div) como 1000 para 1234 (ya que 1234 / 1000 = 1 ) y 100 por 345 (345 / 100 = 3).
Además, mantengamos un diccionario llamado romanNumeral = {1: ‘I’, 5: ‘V’, 10: ‘X’, 50: ‘L’, 100: ‘C’, 500: ‘D’, 1000: ‘M ‘}
El siguiente es el algoritmo:
si dígito significativo principal <= 3
- NúmeroRomano[div] * DígitoSignificantePrincipal
si principal dígito significativo == 4
- númeroromano[div] + númeroromano[div * 5]
si 5 <= dígito significativo principal <=8
- númeroromano[div * 5] + (númeroromano[div] * (principalDígitoSignificativo-5))
si principal dígito significativo ==9
- númeroromano[div] + númeroromano[div*10]
Ejemplo :
suponga que el número de entrada es 3649.
Iter 1
- Número inicial = 3649
- dígito significativo principal es 3. Div = 1000.
- Entonces, númeroromano[1000] * 3
- da: MMM
Iter 2
- ahora, número = 649
- dígito significativo principal es 6. Div = 100.
- Así que númeroromano[100*5] + (númeroromano[div] * (6-5))
- da: CC
Iter 3
- ahora, número = 49
- dígito significativo principal es 4. Div = 10.
- Así que númeroromano[10] + númeroromano[10 * 5]
- da: XL
Iter 4
- ahora, número = 9
- dígito significativo principal es 9. Div = 1.
- Así que númeroromano[1] * númeroromano[1*10]
- da: IX
Resultado final al aporrear todo lo anterior: MMMDCXLIX
A continuación se muestra la implementación de Python de la idea anterior.
C++
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
string integerToRoman(int num) {
unordered_map<int, char> roman; // move outside
roman[1] = 'I';
roman[5] = 'V';
roman[10] = 'X';
roman[50] = 'L';
roman[100] = 'C';
roman[500] = 'D';
roman[1000] = 'M';
roman[5000] = 'G';
roman[10000] = 'H';
string tmp = to_string(num);
const int numDigits = tmp.length();
string res = "";
for(int i=0;i<numDigits;++i) {
const char src = tmp[i]; // orig
const int number = (src - '0'); // convert to integer
const int place = (numDigits-1)-i;
const int absolute = pow(10, place);
if (number == 9) {
res.append(1, roman[absolute]);
res.append(1, roman[(number+1) * absolute]);
} else
if (number >= 5) {
res.append(1, roman[5*absolute]);
res.append(number-5, roman[absolute]);
} else
if (number >= 4) {
res.append(1, roman[absolute]);
res.append(1, roman[5*absolute]);
} else {
res.append(number, roman[absolute]);
}
}
return res;
}
int main() {
cout << integerToRoman(3549) << endl;
return 0;
}
// This code is contributed by elviscastillo.
Python3
# Python 3 program to convert Decimal
# number to Roman numbers.
import math
def integerToRoman(A):
romansDict = \
{
1: "I",
5: "V",
10: "X",
50: "L",
100: "C",
500: "D",
1000: "M",
5000: "G",
10000: "H"
}
div = 1
while A >= div:
div *= 10
div //= 10
res = ""
while A:
# main significant digit extracted
# into lastNum
lastNum = (A // div)
if lastNum <= 3:
res += (romansDict[div] * lastNum)
elif lastNum == 4:
res += (romansDict[div] +
romansDict[div * 5])
elif 5 <= lastNum <= 8:
res += (romansDict[div * 5] +
(romansDict[div] * (lastNum - 5)))
elif lastNum == 9:
res += (romansDict[div] +
romansDict[div * 10])
A = math.floor(A % div)
div //= 10
return res
# Driver code
print("Roman Numeral of Integer is:"
+ str(integerToRoman(3549)))
Producción
Roman Numeral of Integer is:MMMDXLIX
Gracias a Sriharsha Sammeta por proporcionar el enfoque de solución anterior.
Este artículo es una contribución de Rahul Agrawal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA