Question

Rules of implementation!:

• You may NOT modify any of the files except Expression.java in ANY way.
• You may NOT make ANY modifications to Expression.java EXCEPT:
  • Write in the bodies of the methods you are asked to implement,
  • Add private helper methods as needed (including the recursive evaluate method discussed below.)

  Note that the java.io.*, java.util.*, and java.util.regex.* import statements at the top of the file allow for using ANY class in java.io, java.util, and java.util.regex without additional specification or qualification.

Guidelines and recommendations for implementing evaluate

• Recursion (optional) for sub-expressions in parentheses

  While recursion is optional for this assignment, using it to evaluate subexpressions will make it a LOT easier to write working code. (This is a great opportunity to learn how to use recursion in a realistic situation!!)

  There are a couple of coding options if you want to use recursion:

  • One option is to make the public evaluate method itself recursive.

    So, for instance, if the main expression is

    a-(b+A[B[2]])*d+3
    
    01234567891111111  (these are the positions of the characters in the expression)
              0123456
    

    then, to recursively evaluate the subexpression in parentheses, you may call the recursive evaluate method like this:

      float res = evaluate(expr.substring(3,11), vars, arrays);
    

  • Another option is to write a separate private recursive evaluate method, with two indexes that mark the start and end of the subexpression in the main expression. Then, for the above example, you can call the recursive method like this:

       float res = evaluate(expr, 3, 11, vars, arrays);
    

    (The expr parameter is the original expression for every call.)

    And, to start with, you may call the recursive evaluate method from the public evaluate method like this:

       return evaluate(expr, 0, expr.length()-1, vars, arrays);
    

    which is the entire expression.

    You will need to use this second option if you want to include other parameters in your recursive evaluate.

  In either case, the auto grader will call the public evaluate method.
• Recursion (optional) for array index expressions (within '[ and ']'), using the same approach as above.
• A stack may be used to store the values of operands as well as the results from evaluating subexpressions - see next point.
• Since * and / have precedence over + and -, it would help to store operators in another stack. (Think of how you would evaluate a+b*c with operands/intermediate results on one stack and operators on the other.)
• When you implement the evaluate method, you may want to test as you go, implementing code for and testing simple expressions, then building up to more complex expressions. The following is an example sequence of the kinds of expressions you may want to build with:
  • 3
  • a
  • 3+4
  • a+b
  • 3+4*5
  • a+b*c
  • Then introduce parentheses
  • Then try nested parentheses
  • Then introduce array subscripts, but no parentheses
  • Then try nested subscripts, but no parentheses
  • Then try using parentheses as well as array subscripts
  • Then try mixing arrays within parentheses, parentheses within array subscripts, etc.

________________________________________________

HERE ARE THE CLASSES:

package app;

/**

* This class holds a (name, integer value) pair for a simple (non-array) variable.

* The variable name is a sequence of one or more letters.

*

*

*/

public class Variable {

/**

* Name, sequence of letters

*/

public String name;

/**

* Integer value

*/

public int value;

/**

* Initializes with name, and zero value

*

* @param name Variable name

*/

public Variable(String name) {

this.name = name;

value = 0;

}

/* (non-Javadoc)

* @see java.lang.Object#toString()

*/

public String toString() {

return name + "=" + value;

}

/* (non-Javadoc)

* @see java.lang.Object#equals(java.lang.Object)

*/

public boolean equals(Object o) {

if (o == null || !(o instanceof Variable)) {

return false;

}

Variable ss = (Variable)o;

return name.equals(ss.name);

}

}

______________________________________

package app;

/**

* This class holds a (name, array of integer values) pair for an array.

* The name is a sequence of one or more letters.

*

*

*/

public class Array {

/**

* Name, sequence of letters

*/

public String name;

/**

* Array of integer values

*/

public int[] values;

/**

* Initializes with name, and sets values to null.

*

* @param name Name of array

*/

public Array(String name) {

this.name = name;

values = null;

}

/* (non-Javadoc)

* @see java.lang.Object#toString()

*/

public String toString() {

if (values == null || values.length == 0) {

return name + "=[ ]";

}

StringBuilder sb = new StringBuilder();

sb.append(name);

sb.append("=[");

sb.append(values[0]);

for (int i=1; i < values.length; i++) {

sb.append(',');

sb.append(values[i]);

}

sb.append(']');

return sb.toString();

}

/* (non-Javadoc)

* @see java.lang.Object#equals(java.lang.Object)

*/

public boolean equals(Object o) {

if (o == null || !(o instanceof Array)) {

return false;

}

Array as = (Array)o;

return name.equals(as.name);

}

}

________________________

package app;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Evaluator {

   /**
   * @param args
   */
   public static void main(String[] args) throws IOException {
       Scanner sc = new Scanner(System.in);
       while (true) {
           System.out.print("\nEnter the expression, or hit return to quit => ");
           String expr = sc.nextLine();
           if (expr.length() == 0) {
               break;
           }
           ArrayList<Variable> vars = new ArrayList<>();
           ArrayList<Array> arrays = new ArrayList<>();
           Expression.makeVariableLists(expr, vars, arrays);

           System.out.print("Enter variable values file name, or hit return if no variables => ");
           String fname = sc.nextLine();
           if (fname.length() != 0) {
               Scanner scfile = new Scanner(new File(fname));
               Expression.loadVariableValues(scfile, vars, arrays);
           }
           System.out.println("Value of expression = " + Expression.evaluate(expr,vars,arrays));
       }
       sc.close();
   }
}

____________________________

THIS IS THE CLASS WHICH YOU WILL BE WORKING ON:

package app;

import java.io.*;
import java.util.*;
import java.util.regex.*;

import structures.Stack;

public class Expression {

   public static String delims = " \t*+-/()[]";

public static void
makeVariableLists(String expr, ArrayList<Variable> vars, ArrayList<Array> arrays) {
   /** COMPLETE THIS METHOD **/
   /** DO NOT create new vars and arrays - they are already created before being sent in
   ** to this method - you just need to fill them in.
   **/
}

public static void
loadVariableValues(Scanner sc, ArrayList<Variable> vars, ArrayList<Array> arrays)
throws IOException {
while (sc.hasNextLine()) {
StringTokenizer st = new StringTokenizer(sc.nextLine().trim());
int numTokens = st.countTokens();
String tok = st.nextToken();
Variable var = new Variable(tok);
Array arr = new Array(tok);
int vari = vars.indexOf(var);
int arri = arrays.indexOf(arr);
if (vari == -1 && arri == -1) {
   continue;
}
int num = Integer.parseInt(st.nextToken());
if (numTokens == 2) { // scalar symbol
vars.get(vari).value = num;
} else { // array symbol
   arr = arrays.get(arri);
   arr.values = new int[num];
// following are (index,val) pairs
while (st.hasMoreTokens()) {
tok = st.nextToken();
StringTokenizer stt = new StringTokenizer(tok," (,)");
int index = Integer.parseInt(stt.nextToken());
int val = Integer.parseInt(stt.nextToken());
arr.values[index] = val;
}
}
}
}
public static float
evaluate(String expr, ArrayList<Variable> vars, ArrayList<Array> arrays) {
   /** COMPLETE THIS METHOD **/
   // following line just a placeholder for compilation
   return 0;
}
}

__________________________________

Here are some sample expressions of the kind your program will evaluate:

   3
   Xyz
   3-4*5
   a-(b+A[B[2]])*d+3
   A[2*(a+b)]
   (varx + vary*varz[(vara+varb[(a+b)*33])])/55

WILL GIVE THUMBS UP FOR GOOD WORK. PLEASE FOLLOW THE GUIDELINE. THANK YOU.

Answer 1

Please let me know if you have any doubts or you want me to modify the answer. And if you find this answer useful then don't forget to rate my answer as thumps up. Thank you! :)

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;

public class Evaluator {

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.print("\nEnter the expression, or hit return to quit => ");
            String expression = sc.nextLine();
            if (expression.length() == 0) {
                break;
            }
            ArrayList<Variable> variable = new ArrayList<>();
            ArrayList<Array> arrays = new ArrayList<>();
            Expression.makeVariableList(expression, variable, arrays);

            System.out.print("Enter variable values file name, or hit return if no variables => ");
            String fname = sc.nextLine();
            if (fname.length() != 0) {
                Scanner sourcefile = new Scanner(new File("/Users/swapnil/IdeaProjects/ExpressionEvaluatorRecursion/src/input.txt"));
                Expression.loadVariableValues(sourcefile, variable, arrays);
            }
            System.out.println("Value of expression = " + Expression.evaluate(expression,variable,arrays));
        }
        sc.close();
    }
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
public class Array {

    public String name;

    public int[] values;

    public Array(String name) {
        this.name = name;
        values = null;
    }

    public String toString() {
        if (values == null || values.length == 0) {
            return name + "=[ ]";
        }
        StringBuilder sb = new StringBuilder();
        sb.append(name);
        sb.append("=[");
        sb.append(values[0]);
        for (int i = 1; i < values.length; i++) {
            sb.append(',');
            sb.append(values[i]);
        }
        sb.append(']');
        return sb.toString();
    }

    public boolean equals(Object o) {
        if (o == null || !(o instanceof Array)) {
            return false;
        }
        Array as = (Array) o;
        return name.equals(as.name);
    }
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
public class Variable {

    public String name;

    public int value;

    public Variable(String name) {
        this.name = name;
        value = 0;
    }

    public String toString() {
        return name + "=" + value;
    }

    public boolean equals(Object o) {
        if (o == null || !(o instanceof Variable)) {
            return false;
        }
        Variable ss = (Variable)o;
        return name.equals(ss.name);
    }
}

--------------------------------------------------------------------------------------------------------------------------------------------------------------------
import java.io.*;
import java.util.*;

public class Expression {

    public static String delims = " \t*+-/()[]";

    private static boolean arrayExist(ArrayList<Array> arrays, String name) {
        for(int j = 0; j < arrays.size(); j++) {
            if(arrays.get(j).name.equals(name)) {
                return true;
            }
        }
        return false;

    }
    private static boolean variableExist(ArrayList<Variable> variables, String name) {
        for(int j = 0; j < variables.size(); j++) {
            if(variables.get(j).name.equals(name)) {
                return true;
            }
        }
        return false;
    }
    public static void makeVariableList(String expression, ArrayList<Variable> variable, ArrayList<Array> arrays) {
        String current_name;
        expression = expression.trim();
        char expressionTokens [] = expression.toCharArray();
        loop:
        for(int i = 0; i < expression.length(); i ++) {
            char current = expressionTokens[i];
            if(Character.isLetter(current)) {

                switch(current) {
                    case 'v':
                    case 'V':
                        if(expressionTokens.length > i+2) {
                            if(expressionTokens[i+1] == 'a' && expressionTokens[i+2] == 'r') {
                                int end = i;
                                while(Character.isLetter(expressionTokens[end]) && end < expressionTokens.length-1) {
                                    end++;
                                }
                                if(end == expressionTokens.length-1 && Character.isLetter(expressionTokens[end])) {
                                    current_name = expression.substring(i, end+1);
                                } else {
                                    current_name = expression.substring(i, end);
                                }
                                if(expressionTokens[end] == '[') {
                                    if(!arrayExist(arrays, current_name)) {
                                        arrays.add(new Array(current_name));

                                    }
                                    i = end;
                                    continue loop;
                                }
                                if(!variableExist(variable, current_name)) {
                                    variable.add(new Variable(current_name));

                                }
                                i = end;
                                continue loop;
                            }
                        }
                        int end = i;
                        while(Character.isLetter(expressionTokens[end]) && end < expressionTokens.length-1) {
                            end++;
                        }
                        if(end == expressionTokens.length-1 && Character.isLetter(expressionTokens[end])) {
                            current_name = expression.substring(i, end+1);
                        } else {
                            current_name = expression.substring(i, end);
                        }
                        if(expressionTokens[end] == '[') {
                            if(!arrayExist(arrays, current_name)) {
                                arrays.add(new Array(current_name));

                            }
                            i = end;
                            continue loop;
                        }
                        if(!variableExist(variable, current_name)) {
                            variable.add(new Variable(current_name));
                        }
                        i = end;
                        continue loop;

                    default:
                        end = i;
                        while(Character.isLetter(expressionTokens[end]) && end < expressionTokens.length-1) {
                            end++;
                        }
                        if(end == expressionTokens.length-1 && Character.isLetter(expressionTokens[end])) {
                            current_name = expression.substring(i, end+1);
                        } else {
                            current_name = expression.substring(i, end);
                        }
                        if(expressionTokens[end] == '[') {
                            if(!arrayExist(arrays, current_name)) {
                                arrays.add(new Array(current_name));
                            }
                            i = end;
                            continue loop;
                        }
                        if(!variableExist(variable, current_name)) {
                            variable.add(new Variable(current_name));
                        }
                        i = end;
                        continue loop;

                }
            }
        }

    }

    public static void
    loadVariableValues(Scanner sc, ArrayList<Variable> variable, ArrayList<Array> arrays)
            throws IOException {
        while (sc.hasNextLine()) {
            StringTokenizer st = new StringTokenizer(sc.nextLine().trim());
            int numTokens = st.countTokens();
            String tok = st.nextToken();
            Variable var = new Variable(tok);
            Array arr = new Array(tok);
            int vari = variable.indexOf(var);
            int arri = arrays.indexOf(arr);
            if (vari == -1 && arri == -1) {
                continue;
            }
            int num = Integer.parseInt(st.nextToken());
            if (numTokens == 2) {
                variable.get(vari).value = num;
            } else {
                arr = arrays.get(arri);
                arr.values = new int[num];
                while (st.hasMoreTokens()) {
                    tok = st.nextToken();
                    StringTokenizer stt = new StringTokenizer(tok," (,)");
                    int index = Integer.parseInt(stt.nextToken());
                    int val = Integer.parseInt(stt.nextToken());
                    arr.values[index] = val;
                }
            }
        }
    }

    private static int getVarVal(ArrayList<Variable> variable, String name) {
        int i = 0;
        while(!variable.get(i).name.equals(name)) {
            i++;
        }

        return variable.get(i).value;
    }

    private static int getArrVal(ArrayList<Array> arrays, String name, int index) {
        int i = 0;
        while(!arrays.get(i).name.equals(name)) {
            i++;
        }
        return arrays.get(i).values[index];
    }
    private static boolean isPrecedent(char currOperator, char nextOperator) {
        if((currOperator == '*' || currOperator == '/') && (nextOperator == '-' || nextOperator == '+')) {
            return false;
        }
        if((nextOperator ==')' || nextOperator == '(')){
            return false;
        }
        return true;
    }
    private static float operate(float b, float a, char currentOperator) {
        float value = 0;
        switch(currentOperator) {
            case '*':
                value = (a*b);
                break;
            case '/':
                value = (a/b);
                break;
            case '+':
                value = (a+b);
                break;
            case '-':
                value = (a-b);
        }
        return value;
    }

    public static float evaluate(String expr, ArrayList<Variable> variable, ArrayList<Array> arrays) {
        if(expr.isEmpty()) {
            return 0;
        }
        Stack<Float> numberStack = new Stack<Float>();
        Stack<Character> operatorStack = new Stack<Character>();
        String current_name;
        int end = 0;
        expr = expr.trim();
        String [] exprTokens = expr.split("");

        loop:
        for(int i = 0; i < exprTokens.length; i++) {

            char current = exprTokens[i].charAt(0);
            if(Character.isDigit(current)){
                end = i;
                while(Character.isDigit(exprTokens[end].charAt(0)) && end < exprTokens.length-1) {
                    end++;
                }
                if(end == exprTokens.length-1 && Character.isDigit(exprTokens[end].charAt(0))) {
                    end = end+1;
                }
                numberStack.push((float) Long.parseLong(expr.substring(i, end)));
                i = end-1;
                continue loop;

            } else if(Character.isLetter(current)) {
                end = i;
                while(Character.isLetter(exprTokens[end].charAt(0)) && end < exprTokens.length-1) {
                    end++;
                }
                if(end == exprTokens.length-1 && Character.isLetter(exprTokens[end].charAt(0))) {
                    current_name = expr.substring(i, end+1);

                } else {
                    current_name = expr.substring(i, end);

                }
                if(variableExist(variable, current_name)) {
                    numberStack.push((float) getVarVal(variable, current_name));

                    if(end == exprTokens.length-1) {
                        i = end;

                    } else {
                        i = end-1;
                    }
                    continue loop;
                }

                i = end+1;
                end = i;
                int nests = 1;
                int endNests = 0;
                while(nests > endNests) {
                    if(exprTokens[end].charAt(0) == '[') {
                        nests++;
                    } else if(exprTokens[end].charAt(0)== ']') {
                        endNests++;
                        if(endNests == nests) {
                            break;
                        }
                    }
                    end++;
                }

                float index = evaluate(expr.substring(i, end),variable, arrays);
                numberStack.push((float) getArrVal(arrays, current_name, (int) index));
                i = end;
                continue loop;
            } else {
                switch(current) {
                    case '(':

                        i = i+1;

                        end = i;

                        int nests = 1;

                        int endNests = 0;

                        while(nests > endNests) {
                            if(exprTokens[end].charAt(0) == '(') {
                                nests++;
                            } else if(exprTokens[end].charAt(0) == ')') {
                                endNests++;
                                if(endNests == nests) {
                                    break;
                                }
                            }
                            end++;
                        }
                        numberStack.push(evaluate(expr.substring(i, end), variable, arrays));
                        i = end;
                        continue loop;
                    case ' ':
                        continue loop;
                    default:
                        while(!operatorStack.isEmpty() && isPrecedent(current, operatorStack.peek())) {
                            numberStack.push(operate(numberStack.pop(), numberStack.pop(), operatorStack.pop()));
                        }
                        operatorStack.push(current);

                }
            }
        }
        while(!operatorStack.isEmpty()) {
            numberStack.push(operate(numberStack.pop(), numberStack.pop(), operatorStack.pop()));
        }
        return numberStack.pop();

    }
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
//input.txt
a 3
b 2
A 5 (2,3) (4,5)
B 3 (2,1)
d 56