/******************************** R2A_ESP.C *********************************/
/* Creado por: Manuel F Mart¡nez.                          manpaz@email.com */
/* Lenguaje:   C/C++                                                        */
/* Fecha:      Guatemala Mayo 19, 2002                                      */
/* ************************************************************************ */
/* Objetivo: Convierte un n£mero romano a ar bigo, la entrada puede ser un  */
/*           n£mero romano no sensitivo en el rango de 1 a 3999.            */
/* Descripci¢n:  El  programa toma  cada letra y  la va almacenando  en un  */
/*               arreglo de letras, luego convierte cada letra y la guarda  */
/*               en la misma posici¢n en un arreglo de n£meros.             */
/*                                                                                                                                                       */
/*                                En este arreglo se compara si es un n£mero compuesto de 2  */
/*               letras o  de una letra;  si es de dos letras  se hace una  */
/*                                resta si el par esta  escrito correctamente, y este valor  */
/*               se suma a la variable entera que almacena el resultado, y  */
/*                                si el n£mero es de una letra solo se suma el valor de esa  */
/*                                letra romana.                                                            */
/****************************************************************************/
/* NOTA: SI UTILIZA VISUAL C++ PRIMERO CREE UN ESPACIO DE TRABAJO,  SEGUNDO */
/*       ELIMINE LA LINEA "clrscr();" ENTONCES COMPILE EL PROGRAMA.         */
/****************************************************************************/

/* Archivos de cabecera */
#include <conio.h>;
#include <ctype.h>;
#include <stdio.h>;
#include <dos.h>;

int main (void) {
        int numR = 0;         /* Valor decimal de n£mero romano          */
        int decR = 0;        /* Valor decimal de cada n£mero romano */
        int cont = 0;                  /* Posici¢n de la cadena                */
        int cont3R = 0;  /* Contador de 3 incurrencias          */
        int numsR[15] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
                                                                /* Arreglo que almacena el valor de
                                                                        cade letra romana                                     */
        char letraR = ' ';      /* Contiene la letra romana temporal  */
        char roman[15] = "";    /* Contiene la cadena ingresada               */

        /* Borrar la pantalla e imprimir mensaje de ingreso */
        clrscr();
        printf ("Ingrese un n£mero romano en el rango de I a MMMCMXCIX:\n");

        /* Leer desde el teclado hasta que aparezca un <ENTER> */
        while ((letraR != '\n') &#038;&#038; (cont < 15)) {
                letraR = toupper(getchar());

                switch (letraR) {
                        /* V, L y D solo pueden aparecer una vez */
                        case 'V': case 'L': case 'D':
                                /* Si aparecen mas de una vez, entonces termina el programa */
                                if ((cont > 0) &#038;&#038; (roman[cont - 1] == letraR)) {
                                                printf ("\nArgumento no v lido");
                                                delay (1000);
                                                exit (0);
                                }

                                /* Si aparece una vez, se guarda el caracter en la cadena
                                        que almacena los caracteres del n£mero romano         */
                                else { roman[cont++] = letraR; }
                                break;

                        /* I, X, C y M pueden aparecer hasta tres veces */
                        case 'I': case 'X': case 'C': case 'M':
                                /* Si aparece correctamente, se guarda el caracter en la cadena
                                        que almacena los caracteres del n£mero romano               */
                                if (cont3R <= 3) {
                                        roman[cont++] = letraR;
                                }
                                cont3R++;
                                /* Si aparecen mas de tres veces, entonces termina el programa */
                                if ((cont3R > 3) &#038;&#038; (roman[cont - 2] == letraR)) {
                                        printf ("\nArgumento no v lido");
                                        delay (1000);
                                        exit (0);
                                }
                                /* Si el contador de incurrencias llega a 3 pero el caracter
                                        anterior es distinto del actual, entonces se reinicia el
                                        contador de incurrencias                                */
                                if ((cont > 1) &#038;&#038; ((cont3R > 3) || (roman[cont - 2] != letraR))) {
                                        cont3R = 1;
                                }
                                break;

                        /* Invalidar el caracter \n como caracter por defecto */
                        case '\n':      break;

                        /* Si se ingresa un caracter que no pertenece a los n£meros
                                romanos, entonces termina el programa */
                        default:        printf("\nArgumento no v lido");
                                                        delay (1000);
                                                        exit (0);
          }
        }

        /* Reutilizar la variable cont3R como indice de iteraciones para no
                volver a crear una nueva y as¡ optimizar el programa      */

        /* Convertir en decimal cada letra perteneciente al n£mero romano
                que fu‚ ingresado */
        for (cont3R = 0; cont3R <= cont; cont3R++) {
                switch (roman[cont3R]) {
                case 'I':       numsR[cont3R] = 1;        break;
                case 'V':       numsR[cont3R] = 5;        break;
                case 'X':       numsR[cont3R] = 10;      break;
                case 'L':       numsR[cont3R] = 50;      break;
                case 'C':       numsR[cont3R] = 100;    break;
                case 'D':       numsR[cont3R] = 500;    break;
                case 'M':       numsR[cont3R] = 1000; break;
                }
        }

        /* Hacer la sumatoria de los n£meros almacenados */
        for (cont3R = 0; cont3R <= cont; cont3R++) {
                /* Sumar el valor decimal */
                if (numsR[cont3R] >= numsR[cont3R + 1]) {
                        decR = numsR[cont3R];
                }
                /* Si el n£mero precedente es menor y es el 10% o el 5% del actual,
                        entonces hace la resta correspondiente para obtener el valor
                        final p.e. IX = 10 - 1 = 9                                                              */
                if ((numsR[cont3R] == (numsR[cont3R + 1] / 10))
                         || (numsR[cont3R] == (numsR[cont3R + 1] / 5))) {
                        decR = numsR[cont3R + 1] - numsR[cont3R];
                        cont3R++;
                }
                /* Si el n£mero precedente es menor y no es el 10% o el 5% del actual,
                        entonces termina el programa                                                  */
                if (decR < numsR[cont3R + 1]) {
                         printf ("\nArgumento no v lido");
                         delay (1000);
                         exit (0);
                }
                numR += decR;
        }

        /* Imprimir en pantalla el resultado */
        printf ("El valor es %d", numR);

        /* Presionar una tecla para terminar*/
        printf ("\n\n\t\t\t...Presione cualquier tecla para terminar.");
        getch();

        /* Retorno exitoso */
        return 0;
}