CareerCup

public class IntToString {

    static Map<Integer,String>  digit2Text = new HashMap<>();
    static Map<Integer, String> decimalDigits = new HashMap<>();


    static{
        digit2Text.put(1,"one");
        digit2Text.put(2,"two");
        digit2Text.put(3,"three");
        digit2Text.put(4,"four");
        digit2Text.put(5,"five");
        digit2Text.put(6,"six");
        digit2Text.put(7,"seven");
        digit2Text.put(8,"eight");
        digit2Text.put(9,"nine");
        digit2Text.put(10,"ten");
        digit2Text.put(11,"eleven");
        digit2Text.put(12,"twelve");
        digit2Text.put(13,"thirteen");
        digit2Text.put(14,"fourteen");
        digit2Text.put(15,"fifteen");
        digit2Text.put(16,"sixteen");
        digit2Text.put(17,"seventeen");
        digit2Text.put(18,"eighteen");
        digit2Text.put(19,"nineteen");


        decimalDigits.put(2, "twenty");
        decimalDigits.put(3, "thirty");
        decimalDigits.put(4, "fourty");
        decimalDigits.put(5, "fifty");
        decimalDigits.put(6, "sixty");
        decimalDigits.put(7, "seventy");
        decimalDigits.put(8, "eighty");
        decimalDigits.put(9, "ninety");
    }

    public static void main(String[] args){
        System.out.println("55: " + IntToString.getCurrNumStr(55));
        System.out.println("305: " + IntToString.getCurrNumStr(305));
        System.out.println("52168: " + IntToString.int2Str(52168));
        System.out.println("1234567890: " + IntToString.int2Str(1234567890));
    }

    public static Queue<String> getOrder(){
        Queue<String> order = new LinkedList<>();
        order.add("");
        order.add("thousand");
        order.add("million");
        order.add("billion");
        order.add("trillion");
        return order;
    }

    public static String int2Str(int num){
        String retVal = "";
        Queue<String> order = getOrder();

        while(num > 0) {
            String currOrder = order.poll();
            int currNum = num % 1000;
            num = num / 1000;

            retVal = getCurrNumStr(currNum) + " " + currOrder + " "+ retVal;
        }

        return retVal;
    }

    public static String getCurrNumStr(int num){
        String retVal = "";

        int hundreds = num / 100;
        int belowHundreed = num % 100;

        if(belowHundreed < 20){
            retVal = digit2Text.get(belowHundreed);
        } else {
            int digit = belowHundreed % 10;
            int decimalDigit = belowHundreed / 10;

            if (digit != 0) {
                retVal = digit2Text.get(digit);

                if (decimalDigit != 0) {
                    retVal = decimalDigits.get(decimalDigit) + " " + retVal;
                }
            } else {
                if (decimalDigit != 0) {
                    retVal = decimalDigits.get(decimalDigit) + " " + retVal;
                }
            }
        }

        if(hundreds != 0){
            String hundredsStr = digit2Text.get(hundreds);
            hundredsStr = hundredsStr + " hundreed";
            if(retVal.length() > 0){
                retVal = hundredsStr + " and " + retVal;
            } else {
                retVal = hundredsStr;
            }
        }

        return retVal;

    }
}

beautiful

Tried to solve it with a complex logic and it kind of worked but there were too many raise conditions and the code wasn't readable at all.
Using the Dijkstra 2 stack algorithm it is pretty elegant.

public class EvaluateMathematicalExpression {
    Map<Character, Integer> variables;

    public EvaluateMathematicalExpression(Map<Character, Integer> variables) {
        this.variables = variables;                
    }

    public static void main(String[] args){
        Map<Character, Integer> variables = new HashMap<>();
        List<String> expressions = new ArrayList<>();

        Scanner scan = new Scanner(System.in);

        System.out.println("enter number of variables:");
        int variablesNumber = scan.nextInt();
        scan.nextLine();

        System.out.println("now the variables: ");
        for(int i = 0; i<variablesNumber;i++){
            String line = scan.nextLine();
            String[] varVal = line.split("=");
            variables.put(varVal[0].charAt(0),Integer.valueOf(varVal[1]));
        }

        System.out.println("--------------");
        System.out.println("enter number of expressions:");
        int expressionsNumber = scan.nextInt();
        scan.nextLine();

        System.out.println("and the expressions: ");
        for(int i = 0; i<expressionsNumber;i++) {
            expressions.add(scan.nextLine());
        }


        EvaluateMathematicalExpression eme = new EvaluateMathematicalExpression(variables);

        for(String line : expressions){
            try{
                System.out.println("Evaluation of " + line + ": " + eme.evaluateDijkstra(line));
            } catch (Exception e){
                System.out.println("Compile error for " + line);
            }

        }

    }

    public int evaluateDijkstra(String expression){
        char[] chars = expression.toCharArray();

        Stack<Integer>    vals = new Stack<>();
        Stack<Character> ops  = new Stack<>();

        for(int i = 0; i<chars.length;i++){
            char currCh = chars[i];
            if(currCh == ' ') continue;

            if(isSign(currCh)){

                if(!ops.empty() && shouldCalcPrev(currCh, ops.peek())){
                    while(!ops.empty() && ops.peek() != null) {
                        char sign = ops.pop();
                        int right = vals.pop();
                        int left = vals.pop();
                        vals.push(calc(left, right, sign));
                    }
                    ops.push(currCh);
                } else {
                    ops.push(currCh);
                }
            } else {
                Integer val = variables.get(currCh);
                if(val == null){
                    throw new IllegalArgumentException("Unexpected character " + currCh);
                }
                vals.push(val);
            }
        }

        while(!ops.empty()){
            char sign = ops.pop();
            int right = vals.pop();
            int left  = vals.pop();
            vals.push(calc(left,right,sign));
        }

        return vals.pop();
    }

    public int calc(int left, int right, char ch){
        if(ch == '+'){
            return left + right;
        } else if(ch == '-'){
            return left - right;
        } else if(ch == '*'){
            return left * right;
        } else if(ch == '/'){
            return left / right;
        } else {
            throw new IllegalArgumentException("Compilation error, sign expected");
        }
    }

    /**
     * "*" and "/" get higher priority, if we reached to "+" and "-", we can(and should) calculate previous operations.
     * @param sign
     * @param prevSign
     * @return
     */
    public boolean shouldCalcPrev(char sign, Character prevSign){
        if(prevSign == null){
            return false;
        }
        if( (sign == '+' || sign == '-') && (prevSign == '*' || prevSign == '/')) return true;
        return false;
    }

    public boolean isSign(char ch){
        if(ch == '-' || ch == '+' || ch == '*' || ch == '/') return true;
        return false;
    }

}