#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define	STR_LG	32

int Arab2Roman(int nNb, char *pDst)
{
	static char *gpRoman[] =
	{
		"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX",
		"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC",
		"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM",
		"", "M", "MM", "MMM", "MMMM", "", "", "", "", ""
	};

	char	pConv[STR_LG];
	char	*pPtr = pConv;
	int		nCur;

	*pDst = 0;
	if (nNb < 0)
	{
		*pDst = '-';
		*(pDst + 1) = 0;
		nNb = -nNb;
	}
	if (nNb > 4999)
	{
		printf("Les nombres romains ne vont que jusqu'a 4999.\n");
		return (1);
	}

	itoa(nNb, pConv, 10);
	nCur = strlen(pConv);
	while (nCur)
	{
		nCur--;
		strcat(pDst, gpRoman[(nCur * 10) + ((*pPtr++) - '0')]);
	}
	return (0);
}

int main(void)
{
	char	pDst[STR_LG];
	int		nNb;

	printf("Entrez un nombre a convertir en chiffres romains (1-4999) : ");
	scanf("%d", &nNb);

	if (Arab2Roman(nNb, pDst) == 0)
		printf("Representation de %d en chiffres romains : %s\n", nNb, pDst);

	return (0);
}

int Roman2Arab(char *roman, int *arab)
{
  int i;
  char buf[32];

  for(i = 1; i <= 4999; i++)
  {
    if(!Arab2Roman(i, buf)) //La fonction de joe78
    {
      if(!stricmp(buf, roman))
      {
        *arab = i;
        return 1;
      }
    }
  }

  return 0;
}

int Roman2Arab(char *roman)
{
  int i;
  char rom[32];

  for(i = 1; i <= 4999; i++)
  {
    if(!Arab2Roman(i, rom)) //La fonction de joe78
    {
      if(!stricmp(rom, roman))
        return i;
    }
  }

  return 0;
}

#include <stdio.h>
#include <string.h>

int romainVersArabe(char *str)
{
    int vals[256]  = {0};
    int i, res=0;

    vals['I'] = 1; 
    vals['V'] = 5;
    vals['X'] = 10;
    vals['L'] = 50;
    vals['C'] = 100;
    vals['D'] = 500;
    vals['M'] = 1000;

    for(i=0; str[i]; i++)
    {
        if(vals[(int)str[i+1]] > vals[(int)str[i]])
            res -= vals[(int)str[i]];
        else
            res += vals[(int)str[i]];
    }

    return res;
}

char *arabeVersRomain(int N, char *str)
{
    const char *p10[] = {"I", "X", "C", "M"}, *p5[] = {"V","L","D"};
    int size, i;

    str[0] = 0;
    for(i=0; N > 0; i++)
    {
        if(N%5 == 4)
        {
            if(N%10 == 4)
                strcat(str, p5[i]);
            if(N%10 == 9)
                strcat(str, p10[i+1]);
            strcat(str, p10[i]);
        }
        else
        {
            int j=0;
            for(j=0; j<N%5; j++)
                strcat(str, p10[i]);
            if(N%10 >= 5)
                strcat(str, p5[i]);
        }
        N /= 10;
    }

    size = strlen(str);  /*On retourne la chaine*/
    for(i=0; i<size/2; i++)
    {
        int temp = str[i];
        str[i] = str[size-i-1];
        str[size-i-1] = temp;
    }

    return str;
}

int main(void)
{
    char romain[100] = ""; 
    int resultat;

    printf("Entrez un nombre en chiffre romains :\n");
    scanf("%s", romain);
    resultat = romainVersArabe(romain);
    printf("Valeur en chiffres arabes : %d\n", resultat);
    printf("Ecriture correcte en chiffres romains : %s\n", arabeVersRomain(resultat, romain));

    return (0);
}

#include <stdio.h>
#include <string.h>

int romainVersArabe(char *str)
{
    int vals[256]  = {0};
    int i, res=0;

    vals['I'] = vals['i'] = 1; 
    vals['V'] = vals['v'] = 5;
    vals['X'] = vals['x'] = 10;
    vals['L'] = vals['l'] = 50;
    vals['C'] = vals['c'] = 100;
    vals['D'] = vals['d'] = 500; 
    vals['M'] = vals['m'] = 1000;

    for(i=0; str[i]; i++)
    {
        if(vals[(int)str[i+1]] > vals[(int)str[i]])
            res -= vals[(int)str[i]];
        else
            res += vals[(int)str[i]];
    }

    return res;
}

char *arabeVersRomain(int N, char *str)
{
    const char *p10[] = {"I", "X", "C", "M"}, *p5[] = {"V","L","D"};
    int size, i;

    str[0] = 0;
    for(i=0; N > 0; i++)
    {
        if(N%5 == 4)
        {
            if(N%10 == 4)
                strcat(str, p5[i]);
            if(N%10 == 9)
                strcat(str, p10[i+1]);
            strcat(str, p10[i]);
        }
        else
        {
            int j=0;
            for(j=0; j<N%5; j++)
                strcat(str, p10[i]);
            if(N%10 >= 5)
                strcat(str, p5[i]);
        }
        N /= 10;
    }

    size = strlen(str);  /*On retourne la chaine*/
    for(i=0; i<size/2; i++)
    {
        int temp = str[i];
        str[i] = str[size-i-1];
        str[size-i-1] = temp;
    }

    return str;
}

int main(void)
{
    char romain[100] = ""; 
    int resultat;

    printf("Entrez un nombre en chiffre romains (compris entre 1 et 3999) :\n");
    scanf("%s", romain);
    resultat = romainVersArabe(romain);
    if(resultat > 3999)
        printf("Vous avez ecris n'importe quoi\n");
    printf("Valeur en chiffres arabes : %d\n", resultat);
    printf("Ecriture correcte en chiffres romains : %s\n", arabeVersRomain(resultat, romain));
    
    return (0);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


static char const *Nombres[] = { "IV", "IX", "XL", "XC", "CD", "CM", "I", "V",
                                 "X" , "L" , "C" , "D" , "M" };

static long const Valeurs[]  = {  4  ,  9  ,  40 ,  90 , 400 , 900 ,  1 ,  5 ,
                                 10  , 50  , 100 , 500 , 1000 };

long
rtoa (char const *s)
{
   long n = 0;

   while (*s) {
      unsigned i;

      for (i = 0; i < sizeof Nombres; i++) {
         if (strncmp (s, Nombres[i], strlen (Nombres[i])) == 0) {
            n += Valeurs[i];
            s += strlen (Nombres[i]);
            break;
         }
      }
   }

   return n;
}


int
main (void)
{
   char buffer[32];

   if (scanf ("%31s", buffer)) {
      long n;

      n = rtoa (buffer);
      printf ("%ld\n", n);
   }

   return EXIT_SUCCESS;
}

#include <stdio.h>
#include <string.h>

void decimal_vers_romain(char *romain, int x)
{
#define  MILLIERS 4
  char *dix = "IXCM";
  char *cinq = "VLD";
  int position_decimal = 0, position_romain = 0;
  int i, nb_chiffres;
  char decimal[5];

  nb_chiffres = sprintf(decimal, "%d", x);
  for (i = 0; i < nb_chiffres; i++)
    decimal[i] -= '0';

  for (; position_decimal < nb_chiffres; position_decimal++)
    {
      char chiffre = decimal[position_decimal];
      int type_chiffre = nb_chiffres - position_decimal - 1;

      if (type_chiffre == MILLIERS)
        for (i = 0; i < chiffre; i++)
          romain[position_romain++] = 'M';
      else
        switch (chiffre)
          {
          case 1:
          case 2:
          case 3:
            for (i = 0; i < chiffre; i++)
              romain[position_romain++] = dix[type_chiffre];
            break;
          case 4:
            romain[position_romain++] = dix[type_chiffre];
            romain[position_romain++] = cinq[type_chiffre];
            break;
          case 5:
            romain[position_romain++] = cinq[type_chiffre];
            break;
          case 6:
          case 7:
          case 8:
            romain[position_romain++] = cinq[type_chiffre];
            for (i = 0; i < chiffre - 5; i++)
              romain[position_romain++] = dix[type_chiffre];
            break;
          case 9:
            romain[position_romain++] = dix[type_chiffre];
            romain[position_romain++] = dix[type_chiffre + 1];
            break;
          }
    }
}

int romain_vers_decimal(char *romain)
{
  char chiffresRomains[] = "IVXLCDM";
  int valeursDecimales[sizeof(chiffresRomains) - 1] =
    { 1, 5, 10, 50, 100, 500, 1000 };
  int nb_chiffres = strlen(romain), i, ancien, nouveau;
  int resultat;

  ancien = strchr(chiffresRomains, romain[nb_chiffres - 1]) - chiffresRomains;
  resultat = valeursDecimales[ancien];

  for (i = nb_chiffres - 2; i >= 0; i--)
    {
      nouveau = strchr(chiffresRomains, romain[i]) - chiffresRomains;
      if (nouveau >= ancien)
        resultat += valeursDecimales[nouveau];
      else
        resultat -= valeursDecimales[nouveau];
      ancien = nouveau;
    }
  return resultat;
}



int main(void)
{
  int i;
  char romain[100] = { 0 };

  /* exemple inspirés par
     http://en.wikipedia.org/wiki/Roman_numerals#Modern_Roman_numerals */
  char *romains[] =
    { "DCLXVI", "MDCLXVI", "MCCCCCCVI", "MMMDCCCLXXXVIII", "MMMCMXCIX" };

  for (i = 0; i < (int) (sizeof romains / sizeof *romains); i++)
    printf("%s = %d\n", romains[i], romain_vers_decimal(romains[i]));
  decimal_vers_romain(romain, 2011);
  printf("%s = %d\n", romain, 2011);

  /* Test complet de 1 à 3999 */
  for (i = 1; i < 4000; i++)
    {
      char romain[100] = { 0 };
      decimal_vers_romain(romain, i);
      if (romain_vers_decimal(romain) != i)
        {
          printf("%d %s : calcul faux\n", i, romain);
          return 0;
        }
    }
  printf("Test 1 -> 3999 : OK\n");

  return 0;
}

DCLXVI = 666
MDCLXVI = 1666
MCCCCCCVI = 1606
MMMDCCCLXXXVIII = 3888
MMMCMXCIX = 3999
MMXI = 2011
Test 1 -> 3999 : OK

#ifndef ZROM_H
#define ZROM_H

/* constants ================================================================ */
#define ZROM_LONGEST "MMMDCCCLXXXVIII"

/* types ==================================================================== */
typedef struct zrom_t zrom_t; 

/* public functions ========================================================= */
zrom_t * zrom_create(void);
void zrom_delete(zrom_t * zrom);

const char * zrom_get_string(const zrom_t * zrom);
int zrom_get_value(const zrom_t * zrom);

/* ex. 1 */
int zrom_set_string(zrom_t * zrom, const char * string);

/* ex. 2 */
int zrom_set_value(zrom_t * zrom, int value);

/* ex. 3 */
void zrom_sanitize_string(zrom_t * zrom);

#endif

#include "zrom.h"

#include <stdlib.h>
#include <string.h>
#include <errno.h>

/* structures =============================================================== */
struct zrom_t {
    char string[sizeof ZROM_LONGEST];
    int value;
};

/* private functions ======================================================== */
static int zrom_validate_string(const char * string) {
    int valid;

    if (strlen(string) < sizeof ZROM_LONGEST) {
        int i = 0;
        
        valid = 1;
        
        while (string[i] && valid) {
            switch (string[i]) {
                case 'M':
                case 'D':
                case 'C':
                case 'L':
                case 'X':
                case 'V':
                case 'I':
                    break;
                default:
                    valid = 0;
            }

            ++i;
        }
    }
    else {
        valid = 0;
    }

    return valid;
}

static int zrom_get_symbol_value(char symbol) {
    switch (symbol) {
        case 'M':
            return 1000;
        case 'D':
            return 500;
        case 'C':
            return 100;
        case 'L':
            return 50;
        case 'X':
            return 10;
        case 'V':
            return 5;
        case 'I':
            return 1;
        default:
            return 0;
    }
}

/* public functions ========================================================= */
zrom_t * zrom_create(void) {
    return calloc(1, sizeof (zrom_t));
}

void zrom_delete(zrom_t * zrom) {
    free(zrom);
}

const char * zrom_get_string(const zrom_t * zrom) {
    return zrom->string;
}

int zrom_get_value(const zrom_t * zrom) {
    return zrom->value;
}

int zrom_set_string(zrom_t * zrom, const char * string) {
    int error;

    if (zrom_validate_string(string)) {
        int i = 0;
        
        strcpy(zrom->string, string);

        zrom->value = 0;

        while (string[i]) {
            int n = zrom_get_symbol_value(string[i]);

            if (n < zrom_get_symbol_value(string[i + 1])) {
                zrom->value -= n;
            }
            else {
                zrom->value += n;
            }

            ++i;
        }

        error = 0;
    }
    else {
        errno = EINVAL;
        error =  -1;
    }

    return error;
}

int zrom_set_value(zrom_t * zrom, int value) {
    int error;
    
    if (value > 0 && value < 4000) {
        static const char * table[4][10] = {
            {"", "M", "MM", "MMM"},
            {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"},
            {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"},
            {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"}
        };
        
        zrom->value = value;

        strcpy(zrom->string, table[0][value / 1000]);
        value %= 1000;

        strcat(zrom->string, table[1][value / 100]);
        value %= 100;

        strcat(zrom->string, table[2][value / 10]);
        value %= 10;

        strcat(zrom->string, table[3][value]);

        error = 0;
    }
    else {
        errno = EDOM;        
        error =  -1;
    }

    return error;
}

void zrom_sanitize_string(zrom_t * zrom) {
    zrom_set_value(zrom, zrom->value);
}

#include "zrom.h"

#include <stdio.h>

int main(void) {
    zrom_t * zrom = zrom_create();

    if (zrom_set_value(zrom, 42) == 0) {
        printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));
    }
    else {
        perror("zrom_set_value(zrom, 42)");
    }

    if (zrom_set_value(zrom, 0) == 0) {
        printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));
    }
    else {
        perror("zrom_set_value(zrom, 0)");
    }

    if (zrom_set_string(zrom, ZROM_LONGEST) == 0) {
        printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));
    }
    else {
        perror("zrom_set_string(zrom, ZROM_LONGEST)");
    }

    if (zrom_set_string(zrom, "MCMLXXXIV") == 0) {
        printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));
    }
    else {
        perror("zrom_set_string(zrom, \"MCMLXXXIV\")");
    }

    if (zrom_set_string(zrom, ZROM_LONGEST "I") == 0) {
        printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));
    }
    else {
        perror("zrom_set_string(zrom, ZROM_LONGEST \"I\")");
    }

    if (zrom_set_string(zrom, "VVIIIIVI") == 0) {
        printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));
    }
    else {
        perror("zrom_set_string(zrom, \"VVIIIIVI\")");
    }

    zrom_sanitize_string(zrom);
    printf("%s: %d\n", zrom_get_string(zrom), zrom_get_value(zrom));

    zrom_delete(zrom);

    return 0;
}

typedef struct Valeur Valeur;
struct Valeur{
    char lettre;
    int value;
};

int RomToArab(char *rom){
    int i=strlen(rom)-1,arab=0,j=0,prec=0;
    Valeur val[7]={{'I',1},{'V',5},{'X',10},{'L',50},{'C',100},{'D',500},{'M',1000}};
    while(i>=0){
        j=0;
        while(rom[i]!=val[j].lettre) j++;
        prec=val[j].value<prec ? -val[j].value : val[j].value;
        arab+=prec;
        i--;
    }
    return arab;
}

typedef struct Valeur Valeur;
struct Valeur{
    char lettre;
    int value;
};

void ArabToRom(int arab, char* rom){
    int i=6,div=0,j=0;
    Valeur val[7]={{'I',1},{'V',5},{'X',10},{'L',50},{'C',100},{'D',500},{'M',1000}};
    while(i>=0){
        div=arab/val[i].value;
        if(div==4){
            rom[j++]=val[i].lettre;
            rom[j++]=val[i+1].lettre;
            arab-=val[i+1].value-val[i].value;
        }
        else if(div!=0){
            while(div-->0){
                rom[j++]=val[i].lettre;
                arab-=val[i].value;
            }
        }
        i--;
    }
}