roman.java

Go to the documentation of this file.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
 
public class roman {
 
  private static String[][] symbols = {
         {"",  "I",   "II",   "III",   "IV",   "V",   "VI",   "VII",   "VIII",   "IX" },  // units
         {"",  "X",   "XX",   "XXX",   "XL",   "L",   "LX",   "LXX",   "LXXX",   "XC" },  // tens
         {"",  "C",   "CC",   "CCC",   "CD",   "D",   "DC",   "DCC",   "DCCC",   "CM" },  // hundreds
         {"",  "M",   "MM",   "MMM",  "(IV)", "(V)", "(VI)", "(VII)", "(VIII)", "(IX)"},  // thousands
         {"", "(X)", "(XX)", "(XXX)", "(XL)", "(L)", "(LX)", "(LXX)", "(LXXX)", "(XC)"},  // ten thousands
         {"", "(C)", "(CC)", "(CCC)", "(CD)", "(D)", "(DC)", "(DCC)", "(DCCC)", "(CM)"},  // hundred thousands
         {"", "(M)", "(MM)", "(MMM)",     "",    "",     "",      "",       "",     ""}   // millions
  };
 
  private static Map<Character, Integer> d = null;
  static {
      // Roman numerals, as used today, are based on seven symbols:
      d = new HashMap<Character, Integer>();
      d.put ('M', 1000);
      d.put ('D', 500);
      d.put ('C', 100);
      d.put ('L', 50);
      d.put ('X', 10);
      d.put ('V', 5);
      d.put ('I', 1);
  }
 
  private static int[] l = null;
  static {
      l = new int [100];  // initialized with zeroes by default
      
      // An array must be addressed by positive integers.
      // In Java or C, a char is an integer in the ASCII table.
      // Since 'Z' is 90, and we reserved 100
      // positions in the list, we are fine.
 
      l['M'] = 1000;
      l['D'] = 500;
      l['C'] = 100;
      l['L'] = 50;
      l['X'] = 10;
      l['V'] = 5;
      l['I'] = 1;
  }
 
  private static String[] rSymbols = { "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
  private static int[]    decimals = {1000,  900, 500,  400, 100,   90,  50,   40,  10,    9,   5,    4,   1};
 
  private String rnum = null;
 
  private int inum = 0;
 
  public roman () {
  }
 
  public roman ( String r ) throws ValueError {
    String val=validateRoman(r);
    if ( val.length() > 0 ) {
         throw new ValueError(String.format ("Exception %s : Invalid roman \"%s\"", val, r));
    }
 
    rnum = r;
    inum = roman2int ( r );
  }
 
  public roman ( int i ) {
    inum = i;
    rnum = int2roman ( i );
  }
 
  public String toString ( ) {
    return String.format( "%d in roman = %s", inum, rnum );
  }
 
  public int toInt ( ) {
    return inum;
  }
 
  public static String int2roman ( int num ) {
 
    StringBuilder roman = new StringBuilder();         // Construct an empty string builder with 16 characters. 
    if ( (num >= 4000000) || (num < 1) )
        roman.append("N/A");
    else {
        String cnum = baseConverter.itoa ( num, 10 );  // Convert num to String.
        int scnum = cnum.length();
        int strlen = scnum-1;                          // Find out how many digits are in 
                                                       // the input number (magnitude).
/*
        The loop is executed at most 7 times, and 
        it uses no division or multiplication.
*/
        int dig;
        for (int i=0; i<scnum; i++) {                  // Loop forward  (0,1,...,len-1).
            dig = cnum.charAt(i) - '0';                // dig between [0,9]. 
            roman.append (symbols[strlen][dig]);       // Loop backward (len-1,len-2,len-3,...,0).
            strlen -= 1;
        }
    }
 
    return roman.toString().replace ( ")(", "" );
  }
 
public static String int2Roman ( int num ) {
    String roman = "";                   // Empty string
    if ((num >= 4000000) || (num < 1))
        roman = "N/A";
    else {
        int ptr = 0;
        int temp, excess;
 
        if (num >= 4000) {               // The part of the number above 4000
            excess = num/1000;           // should be between parentheses.
            if (excess%10 < 4)           // What is less than 4000 should be
                excess = excess/10*10;   // outside the parentheses.
            roman = "(" + int2Roman (excess) + ")";  // recursive call
            num -= excess*1000;
        }
 
        while (num > 0) {                // Check to see if "num" still has any value left in it.
           temp = num / decimals[ptr];   // See how many of the currently selected value can
                                         // fit in the remaining input.
           for ( int i = 0; i < temp; ++i )
                 roman += rSymbols[ptr]; // Append a number of Roman characters depending
                                         // on the value of "temp".
 
           num -= temp * decimals[ptr];  // Subtract the value of the characters that were
                                         // appended to output from the input.
           ptr += 1;                     // Move the pointer to the next cell of the arrays.
        }
    }
    return roman;
}
 
  public static class ValueError extends Exception {
     private static final long serialVersionUID = 8236264803123918032L;
 
     public ValueError(String message){
         super(message);
     }
  }
 
  public static int roman2int ( String roman ) throws ValueError {
    int total = 0, pptr = 0, cptr = 0;
    boolean m = false;
    int len = roman.length();
    char c;
    String validc = "MDCLXVImdclxvi()";
    for ( int i = 0; i < len; i++ ) {
        c = roman.charAt ( len-i-1 ); // traverse the string backward
        if ( validc.indexOf(c) >= 0 ) {
             if ( c == ')' )
                m = true;
             else if ( c == '(' )
                m = false;
             else {
                cptr = l[Character.toUpperCase(c)];
                if ( m ) cptr *= 1000;
                if (cptr < pptr)
                    total -= cptr;    // IV = 5 - 1, IX = 10 - 1, XL = 50 - 10
                else
                    total += cptr;
                pptr = cptr;
             }
        }
        else
             throw new ValueError(String.format ("Invalid character \"%c\"", c));
    }
    return total;
  }
 
  public static String validateRoman (String romano) {
    romano = romano.toUpperCase();
    String[] s = {romano,""};
 
    int position = romano.indexOf( "(" ); // find first occurrence
    if ( position >= 0 ) {
       int position2 = romano.indexOf( ")" );
       s[0] = romano.substring (position+1, position2); 
       s[1] = romano.substring (position2+1, romano.length());
    }
 
    for ( int j = 0; j < 2; ++j ) {
       String r = s[j];
       int lr = r.length();
       if ( lr == 0 ) continue;
       if ( "MDCLXVI".indexOf(r.charAt(lr-1)) < 0 ) return Character.toString(r.charAt(lr-1));
       for ( int i=0; i < lr-1; ++i ) {
          char c  = r.charAt(i);
          char c1 = r.charAt(i+1);
 
          if ( "MDCLXVI".indexOf(c) < 0) return Character.toString(c);
          if ( (i+2) < lr ) {
              char c2 = r.charAt(i+2); 
              if ( (i+3) < lr ) {
                 char c3 = r.charAt(i+3);
                 if ( c == c1 && c == c2 && c == c3 )
                     return "0: " + r.substring (i,i+4);
              }
              if ( d.get(c2)!=null && (d.get(c) < d.get(c2)) )
                 return "1: " + r.substring (i,i+3);
              if ( "VLD".indexOf(c) >= 0 && c == c2 )
                 return "2: " + r.substring (i,i+3);
              if ( c == 'I' && c2 == 'I' && c1 != 'I' )
                 return "3: " + r.substring (i,i+3);
              if ( c == 'X' && c2 == 'X' && "LC".indexOf(c1) >= 0 )
                 return "4: " + r.substring (i,i+3);
          }
      
          if ( d.get(c1)!=null && (d.get(c) < d.get(c1)) ) {
              if ( "IXC".indexOf(c) < 0 )
                  return "5: " + r.substring (i,i+2);
              if ( c == 'I' && "VX".indexOf(c1) < 0 )
                  return "6: " + r.substring (i,i+2);
              if ( c == 'X' && "LC".indexOf(c1) < 0 )
                  return "7: " + r.substring (i,i+2);
              if ( c == 'C' && "DM".indexOf(c1) < 0 )
                  return "8: " + r.substring (i,i+2);
          }
          if ( "VLD".indexOf(c) >= 0 && c == c1 )
              return "9: " + r.substring (i,i+2);
       }
    }
    return "";
  }
 
  public static void main(String[] args) {
    String jVersion = System.getProperty("java.version");
    jVersion = jVersion.substring(0, 3);
    Float f = Float.valueOf(jVersion);
    if (f.floatValue() < (float)1.5) {
        System.out.println(String.format("Java version %s is too low ....", jVersion));
        System.exit(1);
    }
 
    int r = 0;
    System.out.print ( "Type an integer: " );
    try {
        r = Integer.parseInt(System.console().readLine());
    }
    // catch (NullPointerException | NumberFormatException e) {
    catch (NumberFormatException e) {
        System.out.println ( "A decimal number should have been typed\n" );
    }
    catch (NullPointerException e) {
        // The reason this occurs is because eclipse runs your app as a background process 
        // and not as a top-level process with a system console. 
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        try {
            r = Integer.parseInt(bufferedReader.readLine());
        } catch (IOException e2) {   
            System.out.println (e2);  
            System.out.println ( "A decimal number should have been typed\n" );
        }
    }
    roman rm = new roman(r);
    String rs = roman.int2Roman(r);
    System.out.println ( rm );
    System.out.println ( String.format( "%d in roman = %s", r, rs ) );
 
    try {
       rm = new roman ( rs );
       System.out.println ( String.format( "%s in decimal = %d", rs, rm.toInt() ) );
    }
    catch (ValueError e) {
       System.out.println (e.getMessage());
    }
 
    String invalidRoman[] = { rs, "XXXX", "ivLdi", "IIV", "LXL", "IVI", "XLX", "DM", "iM", "mxm", "CmC", "VV", "va", "xvibc" };
       
    for ( String s : invalidRoman ) {
          String val = roman.validateRoman(s);
          System.out.println ( String.format( "%s is %s%s", s, (val.length()==0)?"valid":"not valid -> ", val ) );
    }
 
    // http://math.hws.edu/eck/cs124/javanotes3/c9/ex-9-3-answer.html
    TextIO.putln("Enter a Roman numeral and I will convert it to an ordinary");
    TextIO.putln("arabic integer.  Enter an integer in the range 1 to 3,999,999");
    TextIO.putln("and I will convert it to a Roman numeral.  Press return when");
    TextIO.putln("you want to quit.");
    while (true) {
           TextIO.putln();
           TextIO.put("? ");
           while (TextIO.peek() == ' ' || TextIO.peek() == '\t')
                  TextIO.getAnyChar();
           if ( TextIO.peek() == '\n' )
               break;
           /* 
              If the first non-blank character is a digit, read an arabic
              numeral and convert it to a Roman numeral.  Otherwise, read
              a Roman numeral and convert it to an arabic numeral. 
           */
           if ( Character.isDigit(TextIO.peek()) ) {
               int arabic = TextIO.getlnInt();
               rm = new roman(arabic);
               TextIO.putln ( rm.toString() );
           }
           else {
               String str = TextIO.getln();
               try {
                  rm = new roman (str);
                  TextIO.putln (str + " in decimal = " + rm.toInt());
               }
               catch (ValueError e) {
                  TextIO.putln (e.getMessage());
               }
           }
    }
    TextIO.putln("OK. Bye for now.");
  }
}