Ruby-Code

def convert_ara(num)
=begin
 In:
  arabian number as int
 Out:
  converted roman number
=end

#Section - Code
 #Section - Declarations
    rom = "" #will contain the converted number
    val = {0..3 => "I", 4..8 => "V", 9 => "XI"}
    
 #Section - Making an array out of num and reversing it in place
    num_arr = num.to_s.each_char.map(&:to_i)
    num_arr.reverse! #to have the ones first and the thousands at the end
    
 #Section - Converting to roman number
    if num > 3999 || num < 1
        puts "Enter a valid number between 1 and 3999.Try again!"
        
    else
        for i in 0..3
            #Switching to tens, hundreds and thousands
            case i
            when 1
                val[0..3] = "X"
                val[4..8] = "L"
                val[9] = "CX" #9 is reverse because of reverse! in the output
                
            when 2
                val[0..3] = "C"
                val[4..8] = "D"
                val[9] = "MC" #9 is reverse because of reverse! in the output
                
            when 3
                val[0..3] = "M"
                val.delete(4..8)
                val.delete(9)
            end
            
            case num_arr[i]
            when 0..3
                num_arr[i].times do
                    rom << "#{val[0..3]}"
                end
            
            when 4..8
                if num_arr[i] - 5 < 0
                    rom << "#{val[4..8]}"
                    rom << "#{val[0..3]}"
                    
                else
                    ((num_arr[i] - 5).abs).times do
                        rom << "#{val[0..3]}"
                    end
                    
                    rom << "#{val[4..8]}"
                end
            
            when 9
                rom << "#{val[num_arr[i]]}"
            end
       end
    end
    
 #Section - Output
    puts "Arabian number: #{num} \nRoman number: #{rom.reverse!}"
end

#=================================================================================

def convert_rom(rom)
=begin
 In:
  roman number as string
 Out:
  converted arabian number
=end

#Section - Code
 #Section - Declarations
    ara = 0 #will contain the converted number
    val_D_L_V = {"V" => 5, "L" => 50, "D" => 500}
    okay = false
    
    #The single invalid patterns for each "roman" number !! for testing the input
    inv_patterns_I = ["IM", "ID", "IC", "IL", "IIX", "IIV"]
    inv_patterns_V = ["VM", "VD", "VC", "VL", "VX", "VV", "VIM", "VID", "VIC", "VIL", "VIX", "VIV", "VIIM", "VIID", "VIIC", "VIIL", "VIIX", "VIIV", "VIIIM", "VIIID", "VIIIC", "VIIIL", "VIIIX", "VIIIV"]
    inv_patterns_X = ["XM", "XD", "XXC", "XXL"]
    inv_patterns_L = ["LM", "LD", "LC", "LL", "LXM", "LXXM", "LXD", "LXXD", "LXC", "LXXC", "LXL", "LXXL", "LXXXM", "LXXXD", "LXXXC", "LXXXL"]
    inv_patterns_C = ["CCM", "CCD", "CDC"]
    inv_patterns_D = ["DM", "DD", "DCM", "DCD", "DCCM", "DCCD", "DCCCM", "DCCCD"]
    inv_patterns_M = ["MMMM"]
    
    #Hash with all (i hope so) invalid patterns to find invalid userinput !! for testing the input
    invalid_patterns = {"M" => inv_patterns_M, "D" => inv_patterns_D, "C" => inv_patterns_C, "L" => inv_patterns_L, "X" => inv_patterns_X, "V" => inv_patterns_V, "I" => inv_patterns_I}
    
    #The single valid patterns for each "roman" number !! for testing the input
    val_patterns_I = {"I" => 1, "II" => 2, "III" => 3, "IV" => -1, "IX" => 9}
    val_patterns_X = {"X" => 10, "XX" => 20, "XXX" => 30, "XL" => -10, "XC" => 90}
    val_patterns_C = {"C" => 100, "CC" => 200, "CCC" => 300, "CD" => -100, "CM" => 900}
    val_patterns_M = {"M" => 1000, "MM" => 2000, "MMM" => 3000}
    
    #Hash with all valid patterns for each number in other hashes
    valid_patterns = {"M" => val_patterns_M, "C" => val_patterns_C, "X" => val_patterns_X, "I" => val_patterns_I}
 
 #Section - Testing the input
    invalid_patterns.keys.each do |romnum| # => M, D, C, L, X, V, I
        
        if rom.include?(romnum)
            
            invalid_patterns[romnum].each do |patt| #patt1, patt2, patt3, ...
                okay = false
                
                if rom.include?(patt)
                    
                    puts "The pattern #{patt} is included in the entered number #{rom}.\nThis means it is no valid roman number."
                    
                    return
                end
            end
        end
    end
    
    puts "The roman number you've entered is valid => C O N V E R T I N G ! !"

 #Section - Converting to arabian number
    invalid_patterns.keys.each do |romnum| # => M, D, C, L, X, V, I
        
        okay = false
        
        if rom.include?(romnum)
            puts "case for #{romnum}" #del
            case romnum
            when "D", "L", "V"
                ara += val_D_L_V[romnum]
                puts "ara = #{ara} after adding #{val_D_L_V[romnum]}"
                okay = true
                
            when "M"
                val_patterns_M.keys.reverse!.each do |valpatt|
                    
                    if rom.include?(valpatt)
                        ara += val_patterns_M[valpatt]
                        puts "ara = #{ara} after adding #{val_patterns_M[valpatt]}"
                        okay = true
                    end
                    
                    break if okay == true
                end
                
            when "C"
                val_patterns_C.keys.reverse!.each do |valpatt|
                
                    if rom.include?(valpatt)
                        ara += val_patterns_C[valpatt]
                        puts "ara = #{ara} after adding #{val_patterns_C[valpatt]}"
                        okay = true
                    end
                    
                    break if okay == true
                end
                
            when "X"
                val_patterns_X.keys.reverse!.each do |valpatt|
                    
                    if rom.include?(valpatt)
                        ara += val_patterns_X[valpatt]
                        puts "ara = #{ara} after adding #{val_patterns_X[valpatt]}"
                        okay = true
                    end
                    
                    break if okay == true
                end
                
            when "I"
                val_patterns_I.keys.reverse!.each do |valpatt|
                    
                    if rom.include?(valpatt)
                        ara += val_patterns_I[valpatt]
                        puts "ara = #{ara} after adding #{val_patterns_I[valpatt]}"
                        okay = true
                    end
                    
                    break if okay == true
                end
                
                break if okay == true
            end
        end
    end
    
 #Section - Output
    puts "-------------------------------------------------------------------------"
    puts "The roman number  : #{rom} has been converted to\nthe arabian number: #{ara}"
    
end

#=============================================================

input = gets.chomp

if input == input.to_i.to_s then
    
    input = input.to_i
    convert_ara(input)
    
else
    
    rom_okay = false
    input = input.upcase!
    
    input.each_byte do |byte|
        
        if byte != 67 && byte != 68 && byte != 73 && byte != 76 && byte != 77 && byte != 86 && byte != 88 then
            
            puts "Please enter a valid roman number"
            break
            
        else
            
            rom_okay = true
            
        end
        
    end
    
    if rom_okay == true then
        
        convert_rom(input)
        
    end
    
end