Roman numerals

  var arab = [ 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 ];
 var roman = [ 'I' , 'IV' , 'V' , 'IX' , 'X' , 'XL' , 'L' , 'XC' , 'C' , 'CD' , 'D' , 'CM ' , ' M ' ];

 function arabToRoman ( number )
 {
	 if ( ! number ) return '' ;

	 var ret = '' ;
	 var i = arab .  length - 1 ;
	 while ( number > 0 )
	 {
		 if ( number > = arab [ i ])
		 {
			 ret + = roman [ i ];
			 number - = arab [ i ];
		 }
		 else
		 {
			 i - ;
		 }
	
	 }
	 return ret ;
 }

 function romanToArab ( str )
 {
	
	 str = str .  toUpperCase ();

	 var ret = 0 ;
	 var i = arab .  length - 1 ;
	 var pos = 0 ;
	 while ( i > = 0 && pos < str . length )
	 {
		 if ( str . substr ( pos , roman [ i ]. length ) == roman [ i ])
		 {
			 ret + = arab [ i ];
			 pos + = roman [ i ].  length ;
		 }
		 else
		 {
			 i - ;
		 }
	
	 }
	 return ret ;
 }

  #include <string.h> 

 const int arabar [] = { 1 , 4 , 5 , 9 , 10 , 40 , 50 , 90 , 100 , 400 , 500 , 900 , 1000 };
 const char * romanar [] = { "I" , "IV" , "V" , "IX" , "X" , "XL" , "L" , "XC" , "C" , "CD" , "D " , " CM " , " M " };
 
 char * arab2roman ( unsigned short int arab ) {
         static char roman [ 80 ];
         const int m = sizeof ( arabar ) / sizeof ( int ) - 1 , arabmax = arabar [ m ];
         const char romanmax = romanar [ m ] [ 0 ];
         int i , n ;
         if ( ! arab ) {
                 * roman = 0 ;
                 return roman ;
         }
         i = 0 ;
         while ( arab > arabmax ) {
                 roman [ i ++ ] = romanmax ;
                 arab - = arabmax ;
         }
         n is m ;
         while ( arab > 0 ) {
                 if ( arab > = arabar [ n ]) {
                         roman [ i ++ ] = romanar [ n ] [ 0 ];
                         if ( n & 1 )
                                 roman [ i ++ ] = romanar [ n ] [ 1 ];
                         arab - = arabar [ n ];
                 } else
                         n is ;
         }
         roman [ i ] = 0 ;
         return roman ;
 }

 unsigned short int roman2arab ( char * roman ) {
         const int m = sizeof ( arabar ) / sizeof ( int ) - 1 ;
         unsigned short int arab ;
         int len , n , i , pir ;
         len = strlen ( roman );

         arab = 0 ;
         n is m ;
         i = 0 ;
         while ( n > = 0 && i < len ) {
                 pir = n & 1 ;
                 if ( roman [ i ] == romanar [ n ] [ 0 ] && ( ! pir || roman [ i + 1 ] == romanar [ n ] [ 1 ])) {
                         arab + = arabar [ n ];
                         i + = 1 + pir ;
                 } else
                         n is ;
         }
         return arab ;
 }

  type str2 = string [ 2 ]; 
 const 
    Rims : array [ 1..14 ] of str2 = ( 'M' , 'CM' , 'D' , 'CD' , 'C' , 'XC' , 'L' , 'XL' , 'X' , ' IX ' , ' V ' , ' IV ' , ' I ' , ' ' ); 
    Arab : array [ 1..14 ] of integer = ( 1000 , 900 , 500 , 400 , 100 , 90 , 50 , 40 , 10 , 9 , 5 , 4 , 1 , 0 ); 
 
 var 
   N , NI , I , J : integer ; 
   S : string ; 
 
   function Arab2Rim ( N : integer ) : string ; 
   var S : string ; 
       I : integer ; 
   begin 
     S : = '' ;  I : = 1 ; 
     while N > 0 do begin 
       while Arab [ I ] <= N do begin 
         S : = S + Rims [ I ]; 
         N : = N - Arab [ I ] 
       end ; 
       I : = I + 1 
     end ; 
     Arab2Rim : = S 
   end ; 
 
   function Rim2Arab ( S : string ) : integer ; 
   var I , N : integer ; 
   begin 
     I : = 1 ;  N : = 0 ; 
     while S <> '' do begin 
       while Rims [ I ] = Copy ( S , 1 , Length ( Rims [ I ]) ) do begin 
         S : = Copy ( S , 1 + Length ( Rims [ I ]), 255 ); 
         N : = N + Arab [ I ] 
       end ; 
       I : = I + 1 
     end ; 
     Rim2Arab : = N 
   end ; 
 
 begin 
   WriteLn ( 'Translation from Arabic numerals to Roman. 1999 B_SA' ); 
 { Write ( 'Enter the number to convert:' );  ReadLn ( N );} 
   for NI : = 26 to 46 do 
     WriteLn ( NI , '=' , Arab2Rim ( NI ), 'back' , Rim2Arab ( Arab2Rim ( NI ) )); 
 end .

  function Arab2Roman ( arab : integer ) : string ;
 var
   i : integer ;
   d : integer ;
   arab_str : string ;
   arab_len : integer ;
 begin
   Result : = '' ;
   arab_str : = IntToStr ( arab ) ;
   arab_len : = Length ( arab_str ) ;
   for i : = 0 to arab_len - 1 do begin
     d : = StrToInt ( String ( arab_str [ arab_len - i ])) ;
     if ( d + 1 ) mod 5 = 0 then
       Result : = Copy ( 'IXCM' , 1 + i , 1 ) + Copy ( 'VXLCDM' , i * 2 + ( d + 1 ) div 5 , 1 ) + Result
     else
       Result : = Copy ( 'VLD' , 1 + i , d div 5 ) + Copy ( 'IIIXXXCCCMMM' , 1 + i * 3 , ( d mod 5 )) + Result ;
   end ;
 end ;

  ten    INPUT    "ARAB NUMBER:" ;    A $
 20    FOR    I = 0    TO    LEN ( A $ ) -1
 thirty    X = VAL ( MID $ ( A $ , LEN ( A $ ) - I , 1 ))
 40    IF    X = 4    OR    X = 9    THEN    B $ = MID $ ( "IXCM" , I + 1 , 1 ) + MID $ ( "VXLCDM" , I * 2 + ( X + 1 ) / 5 , 1 ) + B $
 50    IF    X < 4    THEN    B $ = MID $ ( "IIIXXXCCCMMM" , 1 + I * 3 , X ) + B $
     ELSE    IF    X > 4    AND    X < 9    THEN    B $ = MID $ ( "VLD" , I + 1 , 1 ) + MID $ ( "IIIXXXCCCMMM" , 1 + I * 3 , X -5 ) + B $
 60    NEXT    I
 70    PRINT    "ROMAN NUMBER:" ;    B $

  string-join (
	 for $ num in (1999)
		 return (
			 ('', 'M', 'MM', 'MMM') [($ num idiv 1000) mod 10 + 1],
			 ('', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM') [($ num idiv 100) mod 10+ one],
			 ('', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC') [($ num idiv 10) mod 10+ one],
			 ('', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX') [$ num mod 10 + 1]
		 ),
	 '')

  use strict ;
 use warnings ;

 my $ n = 1999 ;

 my $ nums = [ 
  [ '' , qw (I II III IV V VI VI VII VIII IX) ],
  [ '' , qw (X XX XXX XL L LX LXX LXXX XC) ],
  [ '' , qw (C CC CCC CD D DC DCC DCCC CM) ],
  [ '' , qw (M MM MMM) ]
 ];

 my $ i = 0 ;  my @res = ();
 push @res , ( $ nums -> [ $ i ++ ] [ ( $ n % 10 , $ n = int ( $ n / 10 )) [ 0 ] ]) for 0 .. 3 ;
 print reverse @res ;

  import java.util. * ;

 public class IntegerConverter {

     public static String intToRoman ( int number ) {
         if ( number > = 4000 || number <= 0 )
             return null ;
         StringBuilder result = new StringBuilder ();
         for ( Integer key : units . descendingKeySet ()) {
             while ( number > = key ) {
                 number - = key ;
                 result .  append ( units . get ( key ));
             }
         }
         return result .  toString ();
     }

     private static final NavigableMap < Integer , String > units ;
     static {
         NavigableMap < Integer , String > initMap = new TreeMap <> ();
         initMap .  put ( 1000 , "M" );
         initMap .  put ( 900 , "CM" );
         initMap .  put ( 500 , "D" );
         initMap .  put ( 400 , "CD" );
         initMap .  put ( 100 , "C" );
         initMap .  put ( 90 , "XC" );
         initMap .  put ( 50 , "L" );
         initMap .  put ( 40 , "XL" );
         initMap .  put ( 10 , "X" );
         initMap .  put ( 9 , "IX" );
         initMap .  put ( 5 , "V" );
         initMap .  put ( 4 , "IV" );
         initMap .  put ( 1 , "I" );
         units = Collections .  unmodifiableNavigableMap ( initMap );
     }
 }

  /// <summary>
 /// The class is designed to convert Arabic numbers to Roman and vice versa
 /// </summary>
 /// <remarks>
 /// <para> The class initially contains an alphabet of Roman numbers capable of defining Arabic numbers from 1 to 39999 </para>
 /// <para> If you need to expand the range, then you can define additional notation for Roman numbers using
 /// field <see cref = "Basic Roman Numbers" /> Basic Roman Numbers </remarks>
 public static class Roman
 {
 /// <summary>
 /// Alphabet of basic Roman numbers
 /// <para> The alphabet is built as a dictionary.  The dictionary key is an Arabic number (int), the value is the corresponding
 /// roman number (string) </para>
 /// </summary>
 /// <remarks>
 /// <para> Contains the Roman designation of the Arabic numbers 1 *, 4 *, 5 *, 9 * - where "*" represents 0 ... N zeros </para>
 /// <para> When creating, it contains the notation of numbers from 1 to 10000 (I ... ↂ) Since in a Roman number one character cannot
 /// occurring more than three times, you can initially convert the numbers from 1 to 39999 into the Roman format. </para>
 /// <para> If you want to be able to work with a large number of Roman numbers, then you should add to the list
 /// additional designations starting from 40,000 without missing elements 1 *, 4 *, 5 *, 9 *. </para>
 /// </remarks>
 public static SortedList < int , string > BaseRomanNumbers { get ;  set ;  }

 static Roman Number ()
 {
	 BaseRomanNumbers = new SortedList < int , string > ( 17 );
	 Basic Roman Numbers .  Add ( 1 , "I" );
	 Basic Roman Numbers .  Add ( 4 , "IV" );
	 Basic Roman Numbers .  Add ( 5 , "V" );
	 Basic Roman Numbers .  Add ( 9 , "IX" );
	 Basic Roman Numbers .  Add ( 10 , "X" );
	 Basic Roman Numbers .  Add ( 40 , "XL" );
	 Basic Roman Numbers .  Add ( 50 , "L" );
	 Basic Roman Numbers .  Add ( 90 , "XC" );
	 Basic Roman Numbers .  Add ( 100 , "C" );
	 Basic Roman Numbers .  Add ( 400 , "CD" );
	 Basic Roman Numbers .  Add ( 500 , "D" );
	 Basic Roman Numbers .  Add ( 900 , "CM" );
	 Basic Roman Numbers .  Add ( 1000 , "M" );
	 Basic Roman Numbers .  Add ( 4000 , "Mↁ" );
	 Basic Roman Numbers .  Add ( 5000 , "ↁ" );
	 Basic Roman Numbers .  Add ( 9000 , "Mↂ" );
	 Basic Roman Numbers .  Add ( 10000 , "ↂ" );
 }

 /// <summary>
 /// Calculates the maximum possible Roman number for the current alphabet of Roman numbers.
 /// </summary>
 /// <returns> The highest possible Roman number </returns>
 public static uint MaximumRoman Number () 
 { 
	 int lastNumber = BasicRomanNumbers .  Keys  Last ();
	 int numberNullServer = int .  Parse ( last Number . ToString (). Replace ( '0' , '\ 0' ));
	 int preliminary = 0 ;
	
	 switch ( numberNoZeros )
	 {
		 case 1 :
			 preliminary = last Number * 4 - 1 ;
			 break ;
		 case 4 :
		 case 9 :
			 preliminary = last Number ;
			 break ;
		 case 5 :
			 preliminary = lastNumber + lastNumber / 5 * 3 ;
			 break ;
		 default :
			 break ;
	 }

	 return uint .  Parse ( tentative . ToString (). Replace ( '0' , '9' )) ;; 
 }

 /// <summary>
 /// Converts an integer to a Roman number
 /// </summary>
 /// <param name = "numberArab"> Arabic number to be converted to Roman notation </param>
 /// <exception cref = "ArgumentOutOfRangeException"> Thrown when a number equal to "0" is passed as a parameter
 /// or a number greater than the maximum Roman number. </exception>
 /// <returns> A string representing a Roman number </returns>
 public static string ArabicBRoman ( this int numberArab )
 {
	 StringBuilder number Roman = new StringBuilder ();

	 // Exclude the "-" sign from the Arabic number and make it the first character of the Roman number
	 if ( numberArab < 0 )
	 {
		 Roman number .  Append ( "-" );
		 numberArab = - number ofArab ;
	 }

	 if ( numberArab == 0 )
		 throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , 
			 "Invalid argument value: Roman numbers cannot be equal \" 0 \ "" );
	 else if ( numberArab > MaximumRomanNumber ())
		 throw new ArgumentOutOfRangeException ( "numberArab" , numberArab , 
			 string  Format ( "Invalid argument value: it is not possible to specify a Roman number greater than {0}" ,
				 MaximumRoman Number ()));

	 // We decompose the Arabic number into the Roman numbers that make it up and combine them into one line
	 var necessary Basic Roman Numbers = 
		 from to in Basic Roman Numbers .  Keys 
		 where to <= number of Arab 
		 orderby to descending 
		 select to ;

	 foreach ( int tech in requiredBaseRoman Numbers )
	 {
		 while (( number of Arab / tech ) > = 1 )
		 {
			 numberArab - = tech ;
			 Roman number .  Append ( Basic Roman Numbers [ tech ]);
		 }
	 }

	 return number Roman .  ToString ();
 }

 /// <summary>
 /// Converts Roman to Arabic
 /// </summary>
 /// <param name = "numberRoman"> Roman number to be converted to int type </param>
 /// <exception cref = "FormatException"> Thrown when a non-Roman number is passed as a parameter </exception>
 /// <returns> An integer representing the Arabic notation of a Roman number </returns>
 public static int RomanArabic ( this string numberRoman )
 {
	 int numberArab = 0 ;
	 sbyte negative = 1 ;
	 string rome = number  Trim ();

	 if ( rome [ 0 ] == '-' )
	 {
		 negative = - 1 ;
		 Rome = Rome  Substring ( 1 );
	 }

	 StringBuilder pattern of Roman Number = new StringBuilder ();
	
	 foreach ( int to in Basic Roman Numbers . Keys )
	 {
		 int index = Basic Roman Numbers .  Keys  IndexOf ( k );
		 string quantifier = "?"  ;
		 if ( index == 0 || ( index % 4 ) == 0 )
			 quantifier = "{0,3}" ;

		 Roman number template .  Insert ( 0 , string . Format ( "(? <{0}> ({1}) {2})?" , As ToString (), 
			 BasicRomanNumbers [ k ], quantifier ));
	 }

	 // Ignore case + match should start at the beginning of the line
	 Roman number template .  Insert ( 0 , "(? I) ^" );
	 // Match must be found at the end of the line
	 Roman number template .  Append ( "$" );

	 // Simplified check.  Does not check errors like IVII
	 if (! Regex . IsMatch ( Rome , Roman Number pattern . ToString ()))
		 throw new FormatException ( string . Format ( "Text \" {0} \ "is not a Roman number" , Roman number ));

	 Match number = Regex .  Match ( Rome , Roman Number pattern . ToString ());

	
	 foreach ( int to in Basic Roman Numbers . Keys )
	 {
		 numberArab + = number .  Groups [ to .  ToString ()].  Length / Basic Roman Numbers [ to ].  Length * K ;
	 }
	
	 return numberArab * negative ;
 }
 }