Перевод римских чисел в арабские и наоборот

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <map>
 
using namespace std;
 
///////////////////////////////////////////////////////////////////////////
 
void ThrowEmptyStringError()
{
  throw string("Rome value is empty string.");
}
 
void ThrowBadFormatError(const string& val)
{
  throw "The \"" + val + "\" has incorrect rome number format.";
}
 
void ThrowOutOfRangeOrBadFormatError(const string& val)
{
  throw "The \"" + val + "\" is greater than 3999 or has incorrect rome number format.";
}
 
void ThrowBadConversionError(const string& romeVal, const unsigned correctVal, unsigned conversionResult)
{
  ostringstream oss;
  oss << "The \"" + romeVal + " == " << correctVal << "\" is converted to " << conversionResult << ".";
  throw string(oss.str());
}
 
///////////////////////////////////////////////////////////////////////////
 
const unsigned BAD_VALUE = (unsigned) -1;
typedef pair<string, unsigned> RomeDecPair;
typedef map<string, unsigned> Table;
Table g_table;
 
void InitTables()
{
  g_table["I"] = 1;
  g_table["II"] = 2;
  g_table["III"] = 3;
  g_table["IV"] = 4;
  g_table["V"] = 5;
  g_table["VI"] = 6;
  g_table["VII"] = 7;
  g_table["VIII"] = 8;
  g_table["IX"] = 9;
  g_table["X"] = 10;
  g_table["XX"] = 20;
  g_table["XXX"] = 30;
  g_table["XL"] = 40;
  g_table["L"] = 50;
  g_table["XC"] = 90;
  g_table["C"] = 100;
  g_table["CC"] = 200;
  g_table["CCC"] = 300;
  g_table["CD"] = 400;
  g_table["D"] = 500;
  g_table["CM"] = 900;
  g_table["M"] = 1000;
  g_table["MM"] = 2000;
  g_table["MMM"] = 3000;
}
 
bool StartsWith(const string& romeVal, const string& pattern)
{
  if (romeVal.length() >= pattern.length())
    return romeVal.substr(0, pattern.length()) == pattern;
  return false;
}
 
string GetFirstRomeValue(const string& romeVal)
{
  unsigned maxDecVal = 0;
  const string* result = 0;
  for (Table::const_iterator it = g_table.begin(), end = g_table.end(); it != end; ++it)
  {
    const string& currentRomeVal = it->first;
    const unsigned currentDecVal = it->second;
    if (StartsWith(romeVal, currentRomeVal) && currentDecVal > maxDecVal)
    {
      if (currentRomeVal.length() == 1)
      {
        if (StartsWith(romeVal, string(4, currentRomeVal[0])))
          ThrowBadFormatError(romeVal);
      }
 
      result = &currentRomeVal;
      maxDecVal = currentDecVal;
    }
  }
 
  if (result == 0)
    ThrowBadFormatError(romeVal);
 
  return *result;
}
 
unsigned RomeToDec(const string& romeVal)
{
  if (romeVal.empty())
    ThrowEmptyStringError();
 
  string str = romeVal;
  unsigned result = 0;
  unsigned prevDecVal = 0;
  while (!str.empty())
  {
    const string tmpRomeVal = GetFirstRomeValue(str);
    const unsigned tmpDecVal = g_table[tmpRomeVal];
 
    if (prevDecVal != 0 && prevDecVal <= tmpDecVal)
      ThrowBadFormatError(romeVal);
 
    prevDecVal = tmpDecVal;
    result += tmpDecVal;
 
    if (result >= 4000)
      ThrowOutOfRangeOrBadFormatError(romeVal);
 
    str = str.substr(tmpRomeVal.length());
  }
  return result;
}
 
///////////////////////////////////////////////////////////////////////////
 
void CheckConversion(const RomeDecPair& test)
{
  try
  {
    const unsigned result = RomeToDec(test.first);
    if (result == test.second)
    {
      cout << test.first << " == " << test.second << endl;
    }
    else
    {
      ThrowBadConversionError(test.first, test.second, result);
    }
  }
  catch (const string& errDescr)
  {
    cout << (test.first.empty() ? "#empty#" : test.first.c_str()) << ": failed : " << errDescr << endl;
  }
}
 
int main()
{
  InitTables();
 
  vector<RomeDecPair> tests;
 
  tests.push_back(make_pair("I", 1));
  tests.push_back(make_pair("II", 2));
  tests.push_back(make_pair("III", 3));
  tests.push_back(make_pair("IV", 4));
  tests.push_back(make_pair("V", 5));
  tests.push_back(make_pair("VI", 6));
  tests.push_back(make_pair("VII", 7));
  tests.push_back(make_pair("VIII", 8));
  tests.push_back(make_pair("IX", 9));
  tests.push_back(make_pair("X", 10));
  tests.push_back(make_pair("XI", 11));
  tests.push_back(make_pair("XII", 12));
  tests.push_back(make_pair("XIII", 13));
  tests.push_back(make_pair("XIV", 14));
  tests.push_back(make_pair("XV", 15));
  tests.push_back(make_pair("XVI", 16));
  tests.push_back(make_pair("XVII", 17));
  tests.push_back(make_pair("XVIII", 18));
  tests.push_back(make_pair("XIX", 19));
  tests.push_back(make_pair("XX", 20));
  tests.push_back(make_pair("XXI", 21));
  tests.push_back(make_pair("XL", 40));
  tests.push_back(make_pair("XLII", 42));
  tests.push_back(make_pair("LIX", 59));
  tests.push_back(make_pair("LXXVII", 77));
  tests.push_back(make_pair("XC", 90));
  tests.push_back(make_pair("CX", 110));
  tests.push_back(make_pair("CDXCIX", 499));
  tests.push_back(make_pair("DLXXXIII", 583));
  tests.push_back(make_pair("DCCCLXXXVIII", 888));
  tests.push_back(make_pair("MDCLXVIII", 1668));
  tests.push_back(make_pair("MCMLXXXIX", 1989));
  tests.push_back(make_pair("MMMCMXCIX", 3999));
 
  tests.push_back(make_pair("", BAD_VALUE));
  tests.push_back(make_pair("IIIV", BAD_VALUE));
  tests.push_back(make_pair("IIV", BAD_VALUE));
  tests.push_back(make_pair("IIII", BAD_VALUE));
  tests.push_back(make_pair("IIX", BAD_VALUE));
  tests.push_back(make_pair("XIIII", BAD_VALUE));
  tests.push_back(make_pair("XIIIIX", BAD_VALUE));
  tests.push_back(make_pair("XIIIIX", BAD_VALUE));
  tests.push_back(make_pair("XXXX", BAD_VALUE));
  tests.push_back(make_pair("LL", BAD_VALUE));
  tests.push_back(make_pair("CLC", BAD_VALUE));
  tests.push_back(make_pair("CLL", BAD_VALUE));
  tests.push_back(make_pair("DLD", BAD_VALUE));
  tests.push_back(make_pair("LDD", BAD_VALUE));
  tests.push_back(make_pair("LLI", BAD_VALUE));
  tests.push_back(make_pair("MMMCMXCX", BAD_VALUE));
  tests.push_back(make_pair("AXX", BAD_VALUE));
  tests.push_back(make_pair("LXA", BAD_VALUE));
 
  for (vector<RomeDecPair>::const_iterator it = tests.begin(), end = tests.end(); it != end; ++it)
  {
    CheckConversion(*it);
  }
 
  return 0;
}

#include "stdafx.h"
 
int lookahead=0;                                //считанный символ
int tmp=0,sum=0;                                //значение предыдущего символа, сумма
int repetition=0;                               //количество повторов символов 
 
void error();                                   //Сообщение об ошибке  
bool validterm(int t,char str[],int counter);   //проверка на допустимость символа 
void validation();
 
void term();                                    //Реализация граматики
void rest(int t);
void expr();                        
 
void main() 
{ 
  expr(); 
  printf("%i",sum);
  getch();
} 
 
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Реализация граматики
//EXPR
void expr() 
{ 
  term();
  rest(lookahead);   
} 
 
//TERM
void term()
{
    if(tmp==lookahead) repetition++;            //считаем количество повтров символов
    else repetition=0;
 
    if(lookahead=='I') {        
        sum+=1;                     //I
        tmp='I';
    }    
    else if(lookahead=='V') { 
        if (tmp=='I') sum+=3;       //I TERM1
        else sum+=5;                //TERM1
        tmp='V';
    }    
    else if(lookahead=='X') { 
        if (tmp=='I') sum+=8;       //I TERM1
        else sum+=10;               //TERM1
        tmp='X';
    } 
    else if(lookahead=='L') { 
        if (tmp=='X') sum+=30;      //X TERM2
        else sum+=50;               //TERM2
        tmp='L';
    }    
    else if(lookahead=='C') { 
        if (tmp=='X') sum+=80;      //X TERM2
        else sum+=100;              //TERM2
        tmp='C';
    }    
    else if(lookahead=='D') { 
        if (tmp=='C') sum+=300;     //C TERM3
        else sum+=500;              //TERM3
        tmp='D';
    }    
    else if(lookahead=='M') { 
        if (tmp=='C') sum+=800;     //C TERM3
        else sum+=1000;             //TERM3     
        tmp='M';
    }
 
}
 
//REST
void rest(int t) 
{ 
  if ((lookahead=getchar())!='\n'){  // E 
       validation();
       term();                       //TERM REST
       rest(lookahead); 
  }
} 
 
 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Обработка и поиск ошибок
 
//Проверка на допустимость символа
bool validterm(int ch,char str[],int counter)
{   
    for(int i=0;i<counter;i++)
        if (ch==str[i]) return true;
    return false;
}
 
//сообщение об ошибке
void error() 
{ 
    printf("Sintax error\n");
    getch();
    exit(1);  
} 
 
void validation()
{
       if (!validterm(lookahead,"IVXLCDM",7)) error();              //проверка на допустимость символа
       if(repetition>2) error();                                    //проверка на количество повторений
       if (lookahead==tmp && validterm(lookahead,"VLD",3))error();  //Символы VLD не могут повторяться                            
       if (lookahead=='M' && validterm(tmp,"IVXLD",5)) error();     //проверка выполнения правил вычитания
       if (lookahead=='D' && validterm(tmp,"IVXL",4)) error();
       if (lookahead=='C' && validterm(tmp,"IVL",3)) error();
       if (lookahead=='L' && validterm(tmp,"IV",2)) error();
       if (lookahead=='X' && tmp=='V') error();
       //проверка на количество повторений в правилах вычетания
       if (repetition>0 && tmp=='I' && validterm(lookahead,"VXLCDM",6)) error();
       if (repetition>0 && tmp=='X' && validterm(lookahead,"LCDM",4)) error();
       if (repetition>0 && tmp=='C' && validterm(lookahead,"DM",2)) error();
 
 }

#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <map>
 
using namespace std;
 
///////////////////////////////////////////////////////////////////////////
 
template <typename T>
string ToString(T obj)
{
  stringstream ss;
  ss << obj;
  return ss.str();
}
 
void ThrowEmptyStringError()
{
  throw string("Rome value is empty string.");
}
 
void ThrowBadFormatError(const string& val)
{
  throw "The \"" + val + "\" has incorrect rome number format.";
}
 
void ThrowOutOfRangeOrBadFormatError(const string& val)
{
  throw "The \"" + val + "\" is greater than 3999 or has incorrect rome number format.";
}
 
void ThrowOutOfRangeError(unsigned val)
{
  throw "The \"" + ToString(val) + "\" is greater than 3999 or less than 1.";
}
 
void ThrowCannotConvertError(unsigned val)
{
  throw "Cannot convert the \"" + ToString(val) + "\" to rome value.";
}
 
void ThrowBadConversionError(const string& romeVal, unsigned correctVal, unsigned conversionResult)
{
  ostringstream oss;
  oss << "The \"" + romeVal + " == " << correctVal << "\" is converted to " << conversionResult << ".";
  throw string(oss.str());
}
 
void ThrowBadConversionError(unsigned decVal, const string& correctVal, const string& conversionResult)
{
  ostringstream oss;
  oss << "The \"" << decVal << " == " << correctVal << "\" is converted to " << conversionResult << ".";
  throw string(oss.str());
}
 
///////////////////////////////////////////////////////////////////////////
 
const unsigned BAD_VALUE = (unsigned) -1;
typedef pair<string, unsigned> RomeDecPair;
typedef pair<unsigned, string> DecRomePair;
typedef map<string, unsigned> RomeDecTable;
typedef map<unsigned, string> DecRomeTable;
RomeDecTable g_romeDecTable;
DecRomeTable g_decRomeTable;
 
void InitTables()
{
  g_romeDecTable["I"] = 1;
  g_romeDecTable["II"] = 2;
  g_romeDecTable["III"] = 3;
  g_romeDecTable["IV"] = 4;
  g_romeDecTable["V"] = 5;
  g_romeDecTable["VI"] = 6;
  g_romeDecTable["VII"] = 7;
  g_romeDecTable["VIII"] = 8;
  g_romeDecTable["IX"] = 9;
  g_romeDecTable["X"] = 10;
  g_romeDecTable["XX"] = 20;
  g_romeDecTable["XXX"] = 30;
  g_romeDecTable["XL"] = 40;
  g_romeDecTable["L"] = 50;
  g_romeDecTable["LX"] = 60;
  g_romeDecTable["LXX"] = 70;
  g_romeDecTable["LXXX"] = 80;
  g_romeDecTable["XC"] = 90;
  g_romeDecTable["C"] = 100;
  g_romeDecTable["CC"] = 200;
  g_romeDecTable["CCC"] = 300;
  g_romeDecTable["CD"] = 400;
  g_romeDecTable["D"] = 500;
  g_romeDecTable["DC"] = 600;
  g_romeDecTable["DCC"] = 700;
  g_romeDecTable["DCCC"] = 800;
  g_romeDecTable["CM"] = 900;
  g_romeDecTable["M"] = 1000;
  g_romeDecTable["MM"] = 2000;
  g_romeDecTable["MMM"] = 3000;
 
  for (RomeDecTable::const_iterator it = g_romeDecTable.begin(), end = g_romeDecTable.end(); it != end; ++it)
  {
    g_decRomeTable[it->second] = it->first;
  }
}
 
bool StartsWith(const string& romeVal, const string& pattern)
{
  // Проверка, начинается ли romeVal со строки pattern.
  // romeVal = 123456, pattern = 123, result = true
  // romeVal = 123456, pattern = ab, result = false
 
  if (romeVal.length() >= pattern.length())
    return romeVal.substr(0, pattern.length()) == pattern;
  return false;
}
 
string GetFirstRomeValue(const string& romeVal)
{
  // Возвращает первое распознанное число в строке romeVal или кидает исключение.
  // Поиск числа идет по таблице и возвращается максимальное из всех возможных.
  // Для чила IX возможные кандитаты - это I и IX. Т.к. IX > I результат будет равен IX.
  // romeVal = CIX, result = C
  // romeVal XLII, result = XL
  // romeVal = ABX, throws excepction
 
  unsigned maxDecVal = 0;
  const string* result = 0;
  for (RomeDecTable::const_iterator it = g_romeDecTable.begin(), end = g_romeDecTable.end(); it != end; ++it)
  {
    const string& currentRomeVal = it->first;
    const unsigned currentDecVal = it->second;
    if (StartsWith(romeVal, currentRomeVal) && currentDecVal > maxDecVal)
    {
      if (currentRomeVal.length() == 1)
      {
        // Если число односимвольное, проверяем, не встретилась ли комбинация вроде
        // IIII, XXXX, LLLL, ...
        if (StartsWith(romeVal, string(4, currentRomeVal[0])))
          ThrowBadFormatError(romeVal);
      }
 
      result = &currentRomeVal;
      maxDecVal = currentDecVal;
    }
  }
 
  if (result == 0)
    ThrowBadFormatError(romeVal);
 
  return *result;
}
 
unsigned RomeToDec(const string& romeVal)
{
  if (romeVal.empty())
    ThrowEmptyStringError();
 
  string str = romeVal;
  unsigned result = 0;
  unsigned prevDecVal = 0;
  while (!str.empty())
  {
    const string tmpRomeVal = GetFirstRomeValue(str);
    const unsigned tmpDecVal = g_romeDecTable[tmpRomeVal];
 
    if (prevDecVal != 0)
    {
      // Если мы тут, значит это не первая итерация в цикле.
      // У нас есть предыдущее распознанное число.
 
      if (prevDecVal < 10)
      {
        // числа меньше 10 всегда должны быть последними. Если уже встречалось число,
        // которое меньше 10, значит что-то не так  с форматом римского числа.
        ThrowBadFormatError(romeVal);
      }
 
      if (prevDecVal <= tmpDecVal)
      {
        // Последующее число всегда должно быть меньше прерыдущего.
        // Eсли это не так, то что-то не то с форматом римского числа.
        ThrowBadFormatError(romeVal);
      }
    }
 
    prevDecVal = tmpDecVal;
    result += tmpDecVal;
 
    if (result >= 4000)
      ThrowOutOfRangeOrBadFormatError(romeVal);
 
    // Вычитание из str строки tmpRomeVal.
    // Например, если str == "XVII", а tmpRomeVal == "X", то после вызова substr, переменная
    // str будет равна VII. После этого цикл повторяется уже для строки str="VII"
    str = str.substr(tmpRomeVal.length());
  }
 
  return result;
}
 
bool GetRomeVal(unsigned val, string& result)
{
  DecRomeTable::const_iterator it = g_decRomeTable.find(val);
  if (it == g_decRomeTable.end())
    return false;
 
  result = it->second;
  return true;
}
 
string DecToRome(unsigned val)
{
  if (val < 1 || val > 3999)
    ThrowOutOfRangeError(val);
 
  const unsigned thousends = val / 1000;
  const unsigned hundreds = val % 1000 / 100;
  const unsigned tens = val % 100 / 10;
  const unsigned ed = val % 10;
 
  string strThousends;
  string strHundreds;
  string strTens;
  string strEd;
 
  const bool isOk = (thousends != 0 ? GetRomeVal(thousends * 1000, strThousends) : true)
                 && (hundreds != 0 ? GetRomeVal(hundreds * 100, strHundreds) : true)
                 && (tens != 0 ? GetRomeVal(tens * 10, strTens) : true)
                 && (ed != 0 ? GetRomeVal(ed, strEd) : true)
                 ;
 
  if (!isOk)
  {
    ThrowCannotConvertError(val);
  };
 
  return strThousends + strHundreds + strTens + strEd;
}
 
///////////////////////////////////////////////////////////////////////////
 
void CheckRomeDecConversion(std::string romeVal, unsigned decVal)
{
  try
  {
    const unsigned result = RomeToDec(romeVal);
    if (result == decVal)
    {
      cout << romeVal << " == " << result << endl;
    }
    else
    {
      ThrowBadConversionError(romeVal, decVal, result);
    }
  }
  catch (const string& errDescr)
  {
    cout << (romeVal.empty() ? "#empty#" : romeVal.c_str()) << ": failed : " << errDescr << endl;
  }
}
 
void CheckDecRomeConversion(unsigned decVal, std::string romeVal)
{
  try
  {
    const string result = DecToRome(decVal);
    if (result == romeVal)
    {
      cout << decVal << " == " << result << endl;
    }
    else
    {
      ThrowBadConversionError(decVal, romeVal, result);
    }
  }
  catch (const string& errDescr)
  {
    cout << decVal << ": failed : " << errDescr << endl;
  }
}
 
int main()
{
  InitTables();
 
  vector<RomeDecPair> tests;
 
  tests.push_back(make_pair("I", 1));
  tests.push_back(make_pair("II", 2));
  tests.push_back(make_pair("III", 3));
  tests.push_back(make_pair("IV", 4));
  tests.push_back(make_pair("V", 5));
  tests.push_back(make_pair("VI", 6));
  tests.push_back(make_pair("VII", 7));
  tests.push_back(make_pair("VIII", 8));
  tests.push_back(make_pair("IX", 9));
  tests.push_back(make_pair("X", 10));
  tests.push_back(make_pair("XI", 11));
  tests.push_back(make_pair("XII", 12));
  tests.push_back(make_pair("XIII", 13));
  tests.push_back(make_pair("XIV", 14));
  tests.push_back(make_pair("XV", 15));
  tests.push_back(make_pair("XVI", 16));
  tests.push_back(make_pair("XVII", 17));
  tests.push_back(make_pair("XVIII", 18));
  tests.push_back(make_pair("XIX", 19));
  tests.push_back(make_pair("XX", 20));
  tests.push_back(make_pair("XXI", 21));
  tests.push_back(make_pair("XL", 40));
  tests.push_back(make_pair("XLII", 42));
  tests.push_back(make_pair("LIX", 59));
  tests.push_back(make_pair("LXXVII", 77));
  tests.push_back(make_pair("XC", 90));
  tests.push_back(make_pair("CX", 110));
  tests.push_back(make_pair("CDXCIX", 499));
  tests.push_back(make_pair("DLXXXIII", 583));
  tests.push_back(make_pair("DCCCLXXXVIII", 888));
  tests.push_back(make_pair("MDCLXVIII", 1668));
  tests.push_back(make_pair("MCMLXXXIX", 1989));
  tests.push_back(make_pair("MMMCMXCIX", 3999));
 
  tests.push_back(make_pair("", BAD_VALUE));
  tests.push_back(make_pair("VIV", BAD_VALUE));
  tests.push_back(make_pair("VIIX", BAD_VALUE));
  tests.push_back(make_pair("VIIV", BAD_VALUE));
  tests.push_back(make_pair("VIIXL", BAD_VALUE));
  tests.push_back(make_pair("IIIV", BAD_VALUE));
  tests.push_back(make_pair("IIV", BAD_VALUE));
  tests.push_back(make_pair("IIII", BAD_VALUE));
  tests.push_back(make_pair("IIX", BAD_VALUE));
  tests.push_back(make_pair("XIIII", BAD_VALUE));
  tests.push_back(make_pair("XIIIIX", BAD_VALUE));
  tests.push_back(make_pair("XIIIIX", BAD_VALUE));
  tests.push_back(make_pair("XXXX", BAD_VALUE));
  tests.push_back(make_pair("LL", BAD_VALUE));
  tests.push_back(make_pair("CLC", BAD_VALUE));
  tests.push_back(make_pair("CLL", BAD_VALUE));
  tests.push_back(make_pair("DLD", BAD_VALUE));
  tests.push_back(make_pair("LDD", BAD_VALUE));
  tests.push_back(make_pair("LLI", BAD_VALUE));
  tests.push_back(make_pair("MMMCMXCX", BAD_VALUE));
  tests.push_back(make_pair("AXX", BAD_VALUE));
  tests.push_back(make_pair("LXA", BAD_VALUE));
 
  for (vector<RomeDecPair>::const_iterator it = tests.begin(), end = tests.end(); it != end; ++it)
  {
    if (it->second != BAD_VALUE)
    {
      CheckDecRomeConversion(it->second, it->first);
    }
  }
 
  for (vector<RomeDecPair>::const_iterator it = tests.begin(), end = tests.end(); it != end; ++it)
  {
    CheckRomeDecConversion(it->first, it->second);
  }
 
  return 0;
}

#include<iostream>
 
using namespace std;
 
int main (){
 
 
 
    char lat[100];
    int count = 0 ;
    
    cin.getline(lat,100);
    
    for (int i = 0; i < strlen(lat);i++){
    
        switch(lat[i]){
        
         case 'M': 
            count += 1000;
            break;
        case 'D': 
            count += 500;
            break;
        case 'C':
                   
            if ( i+1 < strlen(lat) && (lat[i + 1] == 'D' || lat[i + 1] == 'M' ) )
                count -= 100;
            else 
                count += 100;
            break;
        case 'L': 
            count += 50;
            break;
        case 'X': 
            if (i+1 < strlen(lat) && (lat[i + 1] == 'L' || lat[i + 1] == 'C' || lat[i + 1] == 'M')  )
                count -= 10;
            else 
                count += 10;
                  
            break;
        case 'V': 
            count += 5;
            break;
        case 'I': 
           if (i+1 < strlen(lat) && (lat[i + 1] == 'V' || lat[i + 1] == 'X' || lat[i + 1] == 'C'))
                count -= 1;
           else count +=1;
                       
            break;
 
        }
        
    
    }
 
    cout << count << endl;
 
    system("pause");
    return EXIT_SUCCESS;
 
 
 
}

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main ()
{
char s [256];
char s1 [256];
int n, c, c1, i, a, k, h;
clrscr();
printf("Vvedite chislo: ");
scanf ("%s",s);
k=strlen(s);
h=0;
for (i=k; i>=0; i--) { s1=s1+s[i]; }   // помогите записать строку s в строку s1 в обратном порядке
i=0;
while (s1[i]!='\0') {   // проверяю пока не дастигнут конец строки s1
 
if (i==0)  {
if  (s[i]==1) s1="I";
if  (s[i]==2) s1="II";
if  (s[i]==3) s1="III";
if  (s[i]==4) s1="VI";
if  (s[i]==5) s1="V";
if  (s[i]==6) s1="IV";
if  (s[i]==7) s1="IIV";
if  (s[i]==8) s1="IIIV";
if  (s[i]==9) s1="XI";
i++   ;
}
 
if (i==1){
if  (s[i]==1) s1=strcat (s1,"X");
if  (s[i]==2) s1=strcat (s1,"XX");
if  (s[i]==3) s1=strcat (s1,"XXX");
if  (s[i]==4) s1=strcat (s1,"LX");
if  (s[i]==5) s1=strcat (s1,"L");
if  (s[i]==6) s1=strcat (s1,"XL");
if  (s[i]==7) s1=strcat (s1,"XXl");
if  (s[i]==8) s1=strcat (s1,"XXXL");
if  (s[i]==9) s1=strcat (s1,"CX");
i++  ;
}
 
if (i==2){
if  (s[i]==1) s1=strcat (s1,"C");
if  (s[i]==2) s1=strcat (s1,"CC");
if  (s[i]==3) s1=strcat (s1,"CCC");
if  (s[i]==4) s1=strcat (s1,"DC");
if  (s[i]==5) s1=strcat (s1,"D");
if  (s[i]==6) s1=strcat (s1,"DC");
if  (s[i]==7) s1=strcat (s1,"DCC");
if  (s[i]==8) s1=strcat (s1,"DCCC");
if  (s[i]==9) s1=strcat (s1,"MC");
i++ ;
}
 
if (i==3){
if  (s[i]==1) s1=strcat (s1,"M");
if  (s[i]==2) s1=strcat (s1,"MM");
if  (s[i]==3) s1=strcat (s1,"MMM");
if  (s[i]==4) s1=strcat (s1,"MMMM");
if  (s[i]==5) s1=strcat (s1,"MMMMM");
if  (s[i]==6) s1=strcat (s1,"MMMMMM");
if  (s[i]==7) s1=strcat (s1,"MMMMMMM");;
if  (s[i]==8) s1=strcat (s1,"MMMMMMMM");
if  (s[i]==9) s1=strcat (s1,"MMMMMMMMM");
i++;
}
 
}
char s2;
int h=strlen (s1);
for (int g=h; g>=0; g--) { s2=s2+s1[g]; }  //переворачиваю строку s1 обратко и записываю в s2
puts (s2);
    getch();
    return 0;
}