int=gets.to_i
k=int
b=[]
arb=[1,4,5,9,10,40,50,90,100,400,500,900,1000,4000]
Roman = { 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"}
while int>0
for i in 0...arb.size-1
if arb[i]>int
b<<Roman[arb[i-1]]
break
end
end
int=int-arb[i-1]
end
puts "#{k} -> #{b.join}"

for i in 0...arb.size-1

for i in 0...arb.size

module RomanNumerus
   def roman(n)
     raise "#{n} > 3888" if n > 3888
     n = n.to_s; ans = ""
     h = {1 => 'I', 5 => 'V', 10 => 'X', 50 => 'L', 100 => 'C', 500 => 'D', 1000 => 'M'}
     for i in 0...n.size
       p = n.size-1-i
       char = n[i].chr.to_i
       case p
         when 3
         ans += h[1000]*char
       else
         j = 10**p
         if char <= 3
           ans += h[j]*char
         elsif char <= 8
           ans += h[5*j]
           if char-5 >= 0
             ans += h[j]*(char-5)
           else
             ans = ans[0...-1]+h[j]+ans[-1].chr
           end
         else
           ans += (h[j]+h[10*j])
         end
       end
     end
     return ans
   end

   def arab(roman)
     ans = 0
     for i in 0...roman.size
       ans += sign(i,roman)
     end
     ans
   end
   
   def sign(i,s)
     raise 'bad Roman num' if s !~ /^[I,X,C,D,L,M,V]{1,}$/
     h = {'I' => 1, 'V' => 5, 'X' => 10, 'L' => 50, 'C' => 100, 'D' => 500, 'M' => 1000}
     return h[s[i].chr] if i == s.size-1
     return h[s[i].chr] < h[s[i+1].chr] ? (-h[s[i].chr]) : (h[s[i].chr])
   end
   
   module_function :roman, :arab    , :sign
end
puts RomanNumerus.roman(3888)
puts RomanNumerus.arab('CCLXXXVIII')

  def decToRome(c)
     dec=c
     raise "Число #{c} больше 3999" if dec.to_i > 3999
     raise "Не существует представления 0 в римской системе счисления" if dec.to_i == 0
     numerals={1=>"I",5=>"V",10=>"X",50=>"L",100=>"C",500=>"D",1000=>"M"}
     rome=""
     pose=dec.size-1
     until dec.empty?
       n=dec.slice!(0..0).to_i
       if n<=3 and
         rome+=numerals[10**pose]*n
       elsif n>3 and n<=5
         rome+=numerals[10**pose]*(5-n)+numerals[5*10**pose]
       elsif n>5 and n<=8
         rome+=numerals[5*10**pose]+numerals[10**pose]*(n-5)
       else
         rome+=numerals[10**pose]+numerals[10**(pose+1)]
       end
       pose-=1
     end
     return rome
   end  
end

irb(main):002:0> "2+34".each_byte { |x| puts x.chr }
2
+
3
4

irb(main):004:0> "2+34".scan(/[0-9]+|./).each { |x| puts x }
2
+
34
=> ["2", "+", "34"]

irb(main):005:0> "100101".to_i(2)
=> 37
irb(main):006:0> 37.to_s(2)
=> "100101"

require 'Stack'

# лМБУУ Compf ЧЩЧЕДЕО ЙЪ ЛМБУУБ Stack Й ЙНЕЕФ НЕФПДЩ
# ЧУЕИ ФТЈИ ФЙРПЧ ДПУФХРБ: public, protected Й private.
#
# лПНРЙМСФПТ ДПРХУЛБЕФ ФПМШЛП ПДОПВХЛЧЕООЩЕ ЙНЕОБ РЕТЕНЕООЩИ!
#
class Compf < Stack
   # рПУМЕДПЧБФЕМШОЩК ЧЩЪПЧ ДМС ЧУЕИ УЙНЧПМПЧ УФТПЛЙ str
   # НЕФПДБ processSymbol.
   def compile(str)
     @ans = ""
     str=str.split("**").map{|i| str[i]+="^"}  
     str=str.join.chop
     "(#{str})".each_byte { |c| processSymbol(c.chr) }
     return @ans
   end

   private

   def symType(c)
     case c
     when '('
       SYM_LEFT
     when ')'
       SYM_RIGHT
     when '+', '-', '*', '/', '^'
       SYM_OPER
     else
       symOther(c)
     end
   end

   def processSymbol(c)
     case symType(c)
     when SYM_LEFT
       push(c)
     when SYM_RIGHT
       processSuspendedSymbol(c)
       pop
     when SYM_OPER
       processSuspendedSymbol(c)
       push(c)
     when SYM_OTHER
       nextOther(c)
     end
   end

   def processSuspendedSymbol(c)
     while precedes(top, c)  
       nextOper(pop)
     end
   end

   def priority(c)
     (c == '+' || c == '-') ? 1 : 2
   end
    
   def precedes(a, b)
     return false if symType(a) == SYM_LEFT  
     return true  if symType(b) == SYM_RIGHT
     priority(a) >= priority(b)
   end
    
   # лЧБМЙЖЙЛБФПТ ДПУФХРБ protected Й НЕФПД nextOther
   # ОХЦОЩ ДМС УПЪДБОЙС ОБ ВБЪЕ ЛМБУУБ Compf ОПЧПЗП ЛМБУУБ
   # Calc, ТЕБМЙЪХАЭЕЗП ЛБМШЛХМСФПТ ЖПТНХМ (ИПФС Ч СЪЩЛЕ
   # Ruby Ч ДБООПН УМХЮБЕ НПЦОП ХВТБФШ "protected", ФЕН
   # УБНЩН ТБЪНЕЭБС ЧУЕ ОЙЦЕПРЙУЩЧБЕНЩЕ ЛПОУФБОФЩ Й НЕФПДЩ
   # Ч ЪПОЕ ДЕКУФЧЙС ЛЧБМЙЖЙЛБФПТБ private, Ч СЪЩЛБИ Java
   # Й C++ ЪДЕУШ ОХЦЕО ЙНЕООП ЛЧБМЙЖЙЛБФПТ protected).
   protected

   SYM_LEFT  = 0; SYM_RIGHT = 1; SYM_OPER  = 2; SYM_OTHER = 3
      
   def symOther(c)
     # уТБЧОЕОЙЕ УЙНЧПМБ У ПВТБЪГПН (ТЕЗХМСТОЩН ЧЩТБЦЕОЙЕН).
     raise "Illegal symbol #{c}" if c !~ /[a-z]/
     SYM_OTHER
   end
    
   def nextOper(c)
#    print "#{c} "  
     if c == '^'
      @ans += "** "
     else
      @ans += "#{c} "
     end  
   end
      
   def nextOther(c)
     nextOper(c)
   end
end

## Compf.rb
require 'Stack'

# Класс Compf выведен из класса Stack и имеет методы
# всех трёх типов доступа: public, protected и private.
#
# Компилятор допускает только однобуквенные имена переменных!
class Compf < Stack
   # Последовательный вызов для всех символов строки str
   # метода processSymbol.
   def compile(str)
     @ans = Array.new
     @last_op = nil
     @index_op1 = 0
     @index_op2 = 0

     "(#{str})".each_byte { |c| processSymbol(c.chr) }
     sort_ans(@index_op1, @index_op2)

     return @ans.join(" ")
   end

   private

   def symType(c)
     case c
     when '('
       SYM_LEFT
     when ')'
       SYM_RIGHT
     when '+', '-', '*', '/'
       SYM_OPER
     else
       symOther(c)
     end
   end

   def processSymbol(c)
     case symType(c)
     when SYM_LEFT
       push(c)
     when SYM_RIGHT
       processSuspendedSymbol(c)
       pop
     when SYM_OPER
       processSuspendedSymbol(c)
       push(c)
     when SYM_OTHER
       nextOther(c)
     end
   end

   def processSuspendedSymbol(c)
     while precedes(top, c)  
       nextOper(pop)
     end
   end

   def priority(c)
     (c == '+' or c == '-') ? 1 : 2
   end
    
   def precedes(a, b)
     return false if symType(a) == SYM_LEFT  
     return true  if symType(b) == SYM_RIGHT
     priority(a) >= priority(b)
   end
    
   # Квалификатор доступа protected и метод nextOther
   # нужны для создания на базе класса Compf нового класса
   # Calc, реализующего калькулятор формул (хотя в языке
   # Ruby в данном случае можно убрать "protected", тем
   # самым размещая все нижеописываемые константы и методы
   # в зоне действия квалификатора private, в языках Java
   # и C++ здесь нужен именно квалификатор protected).
   protected

   SYM_LEFT  = 0; SYM_RIGHT = 1; SYM_OPER  = 2; SYM_OTHER = 3
      
   def symOther(c)
     # Сравнение символа с образцом (регулярным выражением).
     raise "Недопустимый символ #{c}" if c !~ /[a-z]/
     SYM_OTHER
   end
    
   def nextOper(c)
     if symType(c) == SYM_OPER # c == '+' || c == '*'
       if @last_op.nil?
         @index_op1 = (c == '+' || c == '*') ? @ans.length - 2 : @ans.length - 1

       elsif @last_op == c
         if symType(@ans[-1]) == SYM_OTHER && symType(@ans[-2]) == SYM_OTHER
           sort_ans(@index_op1, @index_op2)
           @index_op1 = (c == '+' || c == '*') ? @ans.length - 2 : @ans.length - 1           
         end

       else
         sort_ans(@index_op1, @index_op2)

         if symType(@ans[-1]) == SYM_OTHER && symType(@ans[-2]) == SYM_OTHER
           @index_op1 = (c == '+' || c == '*') ? @ans.length - 2 : @ans.length - 1
         else
           @index_op1 = @ans.length - 1
         end
       end

       @last_op = c
       @index_op2 = @ans.length
     end

     @ans << c
   end
      
   def nextOther(c)
     nextOper(c)
   end

   def sort_ans(f, t)
     for i in (f+1)...t
       for j in f...i
         if symType(@ans[i]) == SYM_OTHER &&  
            symType(@ans[j]) == SYM_OTHER &&
            @ans[i] < @ans[j]
           @ans[i], @ans[j] = @ans[j], @ans[i]
         end
       end
     end
   end

end