Conversor de números romanos en C++

1. Conversor de números romanos en C++
2. Convertir un número decimal a un número romano en C++
3. Ejemplo de código C++ para convertir un número decimal en un número romano
4. Conclusión

En el mundo de hoy, existen múltiples sistemas numéricos con los que estamos tratando para ayudar a representar los números de diferentes maneras. Uno de ellos es el sistema numérico romano.

Los antiguos romanos los inventaron para contar y realizar las actividades del día a día. Este artículo discutirá el sistema numérico romano y el programa para convertir un número decimal en un número romano.

Conversor de números romanos en C++

Los números romanos representan un número en un formato específico para contar y otros fines.

Seguro que has oído hablar de estos números romanos en las escuelas y has visto su ejemplo práctico en los relojes. Los números romanos a menudo representan los números en los relojes.

El sistema de números romanos está representado por una combinación de siete letras del alfabeto latino. Cada una de las siete letras o símbolos tiene un valor definido adjunto.

Las siete letras y sus valores específicos se especifican a continuación.

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

Sin embargo, una cosa para recordar es que después de 1000, no tenemos ningún símbolo para 10000; por lo tanto, el número más alto que pueden representar los números romanos es 3999.

Ahora, hablemos sobre cómo convertir números decimales en números romanos.

Un número en un número romano se escribe en orden descendente, de izquierda a derecha; sin embargo, en algunos casos, para evitar la repetición de los mismos cuatro caracteres consecutivos, como (IIII o XXXX), se sigue la notación sustractiva. La notación sustractiva se usa con los números que tienen 4 y 9 en ellos.

En la notación sustractiva, I se coloca antes de V o X para convertirlo en IV (cuatro) o IX (nueve). Del mismo modo, se antepone X a L o C para convertirlo en XL o XC.

Por lo tanto, los símbolos en la notación sustractiva se forman combinando dos símbolos. Por lo tanto, veamos los números romanos que también incluyen la notación sustractiva.

SYMBOL        Number
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

Convertir un número decimal a un número romano en C++

El procedimiento para convertir un número entero en un número romano es el siguiente:

1. Repita el proceso a continuación hasta que el número decimal dado se convierta en cero.
2. Necesitamos comparar el número decimal con los valores base en el orden especificado como 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1.
3. Si el valor base es menor o igual que el número decimal dado (valor base más grande), divida el número decimal por el valor base.
4. Ahora, agregue el símbolo correspondiente del valor base, el número de veces del cociente en una variable. Por ejemplo: si el cociente resulta 3 y el valor base es 10, entonces la representación correspondiente de 10, es decir, X, se repetirá tres veces como XXX en la respuesta.
5. Sin embargo, el resto se convierte en el nuevo número para futuras divisiones.
6. La variable que tiene los símbolos adjuntos hasta que el número decimal se convierte en cero contiene la respuesta.

Tomemos el número 2954 como decimal para convertirlo a un número romano usando el algoritmo anterior.

Producción :

MMCMLIV

Explicación:

Nivel 1:

1. Inicialmente, el número decimal es 2954.
2. Desde 2954>=1000, el valor base más grande corresponde a 1000.
3. Dividiendo 2954 por 1000 da cociente = 2 y resto = 954. Como el símbolo correspondiente a 1000 es M, se repetirá dos veces.
4. Por tanto, el resultado, por ahora, es igual a MM.
5. El resto se convierte en el nuevo número para realizar las divisiones posteriores.

Etapa 2:

1. Ahora, el número se convierte en 954.
2. Comparándolo con los valores base 1000>954>=900. Por lo tanto, el valor base más grande es 900.
3. Dividir 954 por 900 da cociente = 1 y resto = 54. Dado que el símbolo correspondiente a 900 es CM, se agregará una vez.
4. Por lo tanto, el resultado ahora se convierte en MMCM.
5. El resto se convierte en el nuevo número para realizar las divisiones posteriores.

Etapa 3:

1. Ahora, el número se convierte en 54.
2. Comparándolo con los valores base 90>54>=50. Por lo tanto, el valor base más grande es 50.
3. Dividiendo 54 por 50 da cociente = 1 y resto = 4. Dado que el símbolo correspondiente a 50 es L, se añadirá una vez.
4. Por lo tanto, el resultado ahora se convierte en MMCML.
5. El resto se convierte en el nuevo número para realizar las divisiones posteriores.

Etapa 4:

1. Ahora, el número se convierte en 4.
2. Comparándolo con los valores base 5>4>=4. Por lo tanto, el valor base más grande es 4.
3. Dividiendo 4 por 4 da cociente = 1 y resto = 0. Dado que el símbolo correspondiente a 4 es IV, se añadirá una vez.
4. Por lo tanto, el resultado ahora se convierte en MMCMLIV.
5. Ahora, dado que el resto se vuelve cero, las iteraciones se detendrán y tenemos la respuesta requerida.

Ejemplo de código C++ para convertir un número decimal en un número romano

Veamos un ejemplo de código para convertir un número decimal a un número romano en C++.

#include <bits/stdc++.h>
using namespace std;

int subDig(char n1, char n2, int i, char c[]) {
  c[i++] = n1;
  c[i++] = n2;
  return i;
}

int digit(char ch, int n, int i, char c[]) {
  for (int j = 0; j < n; j++) {
    c[i++] = ch;
  }
  return i;
}

int convertRoman(int num) {
  char c[10001];
  int i = 0;
  while (num != 0) {
    if (num >= 1000) {
      i = digit('M', num / 1000, i, c);
      num = num % 1000;
    } else if (num >= 500) {
      if (num < 900) {
        i = digit('D', num / 500, i, c);
        num = num % 500;
      } else {
        i = subDig('C', 'M', i, c);
        num = num % 100;
      }
    } else if (num >= 100) {
      if (num < 400) {
        i = digit('C', num / 100, i, c);
        num = num % 100;
      } else {
        i = subDig('C', 'D', i, c);
        num = num % 100;
      }
    } else if (num >= 50) {
      if (num < 90) {
        i = digit('L', num / 50, i, c);
        num = num % 50;
      } else {
        i = subDig('X', 'C', i, c);
        num = num % 10;
      }
    } else if (num >= 10) {
      if (num < 40) {
        i = digit('X', num / 10, i, c);
        num = num % 10;
      } else {
        i = subDig('X', 'L', i, c);
        num = num % 10;
      }
    } else if (num >= 5) {
      if (num < 9) {
        i = digit('V', num / 5, i, c);
        num = num % 5;
      } else {
        i = subDig('I', 'X', i, c);
        num = 0;
      }
    } else if (num >= 1) {
      if (num < 4) {
        i = digit('I', num, i, c);
        num = 0;
      } else {
        i = subDig('I', 'V', i, c);
        num = 0;
      }
    }
  }

  for (int j = 0; j < i; j++) {
    cout << c[j];
  }
}

int main() {
  int number = 2954;

  convertRoman(number);

  return 0;
}

Producción :

MMCMLIV

En el código anterior, hemos comparado el número num con los valores base usando las condiciones if/else, y en base a esto, hemos agregado la variable correspondiente a la respuesta.

Sin embargo, los números que siguen a la notación sustractiva se han tratado por separado con la función subDig en la que se han añadido dos símbolos de letras a la respuesta.

El código discutido anteriormente es bastante largo; por lo tanto, analicemos un enfoque diferente en el que nuestro código se reduce a un código mucho más corto que el discutido anteriormente.

Enfoque 2

Este enfoque se basa en almacenar los valores base y sus símbolos correspondientes por separado en una matriz y usarlos mientras se realiza un bucle.

Veamos el código del mismo.

#include <bits/stdc++.h>
using namespace std;

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

Producción :

MMDXLIII

En el código anterior, almacenamos los valores base y sus símbolos correspondientes en una matriz y luego comparamos el número con los valores base en orden decreciente.

Después de esto, el número se divide con el mayor valor base y se encuentran el cociente y el resto. Ahora, el símbolo correspondiente se imprime varias veces usando un bucle while.

Conclusión

En este artículo, hemos discutido la conversión de números decimales a números romanos. Los números romanos son una forma de representar el número decimal con símbolos.

Los números romanos se escriben en orden decreciente y de izquierda a derecha. Sin embargo, en algunos casos, usamos una notación sustractiva, en la que se escribe un símbolo más pequeño antes de uno más grande.

Estos casos surgen con los números 4 y 9 y se explican en este artículo.