Revisions to Evaluating a math expression given in string format

formatting

Source Link

edited Jul 23, 2019 at 14:02

14.2k
3
40
101

public static String evaluate(String expression) {
        char[] tokens = expression.toCharArray();
        List<String> list = new ArrayList<>();

        String s = "";

        String operator = "";
        String firstNum = "";
        String secondNum = "";

        boolean operationOnQueue = false;

        for (int i = 0; i < tokens.length; i++) {
            if (Character.isDigit(tokens[i])) {
                s += Character.toString(tokens[i]);
            } else {
                list.add(s);
                list.add(Character.toString(tokens[i]));

                if (operationOnQueue) {
                    operationOnQueue = false;
                    secondNum = s;

                    list.set(list.lastIndexOf(firstNum), eval(firstNum, operator, secondNum));
                    list.remove(list.lastIndexOf(operator));
                    list.remove(list.lastIndexOf(secondNum));
                }

                if (tokens[i] == '*' || tokens[i] == '/') {
                    operationOnQueue = true;

                    operator = Character.toString(tokens[i]);
                    firstNum = list.get(list.lastIndexOf(operator) - 1);
                }

                s = "";
            }

            if (i == tokens.length - 1 && s.length() > 0) {
                list.add(s);

                if (list.get(list.size() - 2).equals("*") || list.get(list.size() - 2).equals("/")) {
                    firstNum = list.get(list.size() - 3);
                    operator = list.get(list.size() - 2);
                    secondNum = list.get(list.size() - 1);

                    list.set(list.size() - 3, eval(firstNum, operator, secondNum));
                    list.remove(list.size() - 2);
                    list.remove(list.size() - 1);
                }
            }
        }


        while (list.size() > 1) {
            firstNum = list.get(0);
            operator = list.get(1);
            secondNum = list.get(2);

            list.set(0, eval(firstNum, operator, secondNum));
            list.remove(2);
            list.remove(1);
        }

        return list.get(0);
    }

 
public static String eval(String a, String operator, String b) {
        double r = 0;

        switch (operator) {
            case "/":
                r += Double.parseDouble(a) / Double.parseDouble(b);
                break;
            case "*":
                r += Double.parseDouble(a) * Double.parseDouble(b);
                break;
            case "-":
                r += Double.parseDouble(a) - Double.parseDouble(b);
                break;
            case "+":
                r += Double.parseDouble(a) + Double.parseDouble(b);
                break;
        }

        return Double.toString(r);
    }

public static String evaluate(String expression) {
        char[] tokens = expression.toCharArray();
        List<String> list = new ArrayList<>();

        String s = "";

        String operator = "";
        String firstNum = "";
        String secondNum = "";

        boolean operationOnQueue = false;

        for (int i = 0; i < tokens.length; i++) {
            if (Character.isDigit(tokens[i])) {
                s += Character.toString(tokens[i]);
            } else {
                list.add(s);
                list.add(Character.toString(tokens[i]));

                if (operationOnQueue) {
                    operationOnQueue = false;
                    secondNum = s;

                    list.set(list.lastIndexOf(firstNum), eval(firstNum, operator, secondNum));
                    list.remove(list.lastIndexOf(operator));
                    list.remove(list.lastIndexOf(secondNum));
                }

                if (tokens[i] == '*' || tokens[i] == '/') {
                    operationOnQueue = true;

                    operator = Character.toString(tokens[i]);
                    firstNum = list.get(list.lastIndexOf(operator) - 1);
                }

                s = "";
            }

            if (i == tokens.length - 1 && s.length() > 0) {
                list.add(s);

                if (list.get(list.size() - 2).equals("*") || list.get(list.size() - 2).equals("/")) {
                    firstNum = list.get(list.size() - 3);
                    operator = list.get(list.size() - 2);
                    secondNum = list.get(list.size() - 1);

                    list.set(list.size() - 3, eval(firstNum, operator, secondNum));
                    list.remove(list.size() - 2);
                    list.remove(list.size() - 1);
                }
            }
        }


        while (list.size() > 1) {
            firstNum = list.get(0);
            operator = list.get(1);
            secondNum = list.get(2);

            list.set(0, eval(firstNum, operator, secondNum));
            list.remove(2);
            list.remove(1);
        }

        return list.get(0);
    }

public static String eval(String a, String operator, String b) {
        double r = 0;

        switch (operator) {
            case "/":
                r += Double.parseDouble(a) / Double.parseDouble(b);
                break;
            case "*":
                r += Double.parseDouble(a) * Double.parseDouble(b);
                break;
            case "-":
                r += Double.parseDouble(a) - Double.parseDouble(b);
                break;
            case "+":
                r += Double.parseDouble(a) + Double.parseDouble(b);
                break;
        }

        return Double.toString(r);
    }

public static String evaluate(String expression) {
    char[] tokens = expression.toCharArray();
    List<String> list = new ArrayList<>();

    String s = "";

    String operator = "";
    String firstNum = "";
    String secondNum = "";

    boolean operationOnQueue = false;

    for (int i = 0; i < tokens.length; i++) {
        if (Character.isDigit(tokens[i])) {
            s += Character.toString(tokens[i]);
        } else {
            list.add(s);
            list.add(Character.toString(tokens[i]));

            if (operationOnQueue) {
                operationOnQueue = false;
                secondNum = s;

                list.set(list.lastIndexOf(firstNum), eval(firstNum, operator, secondNum));
                list.remove(list.lastIndexOf(operator));
                list.remove(list.lastIndexOf(secondNum));
            }

            if (tokens[i] == '*' || tokens[i] == '/') {
                operationOnQueue = true;

                operator = Character.toString(tokens[i]);
                firstNum = list.get(list.lastIndexOf(operator) - 1);
            }

            s = "";
        }

        if (i == tokens.length - 1 && s.length() > 0) {
            list.add(s);

            if (list.get(list.size() - 2).equals("*") || list.get(list.size() - 2).equals("/")) {
                firstNum = list.get(list.size() - 3);
                operator = list.get(list.size() - 2);
                secondNum = list.get(list.size() - 1);

                list.set(list.size() - 3, eval(firstNum, operator, secondNum));
                list.remove(list.size() - 2);
                list.remove(list.size() - 1);
            }
        }
    }


    while (list.size() > 1) {
        firstNum = list.get(0);
        operator = list.get(1);
        secondNum = list.get(2);

        list.set(0, eval(firstNum, operator, secondNum));
        list.remove(2);
        list.remove(1);
    }

    return list.get(0);
}

 
public static String eval(String a, String operator, String b) {
    double r = 0;

    switch (operator) {
        case "/":
            r += Double.parseDouble(a) / Double.parseDouble(b);
            break;
        case "*":
            r += Double.parseDouble(a) * Double.parseDouble(b);
            break;
        case "-":
            r += Double.parseDouble(a) - Double.parseDouble(b);
            break;
        case "+":
            r += Double.parseDouble(a) + Double.parseDouble(b);
            break;
    }

    return Double.toString(r);
}

fixed bugs and added unit tests

Source Link

edited Jul 22, 2019 at 22:31

rad

61
1
1
5

What can I improve? Is there anything you would recommend me to change to optimize my program?

public static String evaluate(String expression) {
        char[] tokens = expression.toCharArray();
        List<String> stacklist = new ArrayList<>();

        String s = "";

        String operator = "";
        String firstNum = "";
        String secondNum = "";

        boolean operationOnQueue = false;

        for (int i = 0; i < tokens.length; i++) {
            if (Character.isDigit(tokens[i])) {
                s += Character.toString(tokens[i]);
            } else {
            stack    list.add(s);
            stack    list.add(Character.toString(tokens[i])); 

            s    if (operationOnQueue) {
                    operationOnQueue = "";false;
        }            secondNum = s;

        if (i == tokens.length - 1 && s     list.lengthset(list.lastIndexOf(firstNum), >eval(firstNum, 0)operator, {secondNum));
            stack        list.addremove(slist.lastIndexOf(operator));
        }

        if (Character.isDigit(tokens[i]) && stack list.sizeremove(list.lastIndexOf(secondNum) > 4) {;
            String a, b, num1, num2;}

                if (itokens[i] <== tokens.length'*' -|| 1tokens[i] == '/') {
                a = stack.get(stack.size() - 5);operationOnQueue = true;

                b    operator = stack.get(stackCharacter.sizetoString() - 3tokens[i]);
                num1    firstNum = stacklist.get(stacklist.sizelastIndexOf(operator) - 41);
                num2}

 = stack.get(stack.size() - 2);
            }s else= {"";
            }

       a = stack.get   if (stacki == tokens.sizelength - 1 && s.length() -> 40) {
                list.add(s); 

                bif =(list.get(list.size() stack- 2).equals("*") || list.get(stacklist.size() - 2);.equals("/")) {
                num1    firstNum = stacklist.get(stacklist.size() - 3);
                num2    operator = stacklist.get(stacklist.size() - 12);
            }

           secondNum if= list.get(hasPrecedencelist.size(b, a)) {- 1);

                stack    list.set(stacklist.indexOfsize(num1) - 3, eval(num1firstNum, num2operator, bsecondNum));
            } else {      list.remove(list.size() - 2);
                stack    list.setremove(stacklist.indexOfsize(num1), eval(num1, num2,- a)1);
                }
            }
        }


    stack.remove    while (stacklist.lastIndexOfsize(b) > 1); {
            stack.remove(stackfirstNum = list.lastIndexOfget(num2)0);
        }
    }
operator = list.get(1);
    String ans       secondNum = eval(stacklist.get(02),;

 stack           list.getset(2)0, stack.geteval(1firstNum, operator, secondNum));
    return ans;
}

public boolean hasPrecedence(String a, String b) { list.remove(2);
    return (a.equals("*") || a.equals("/")) && (b   list.equalsremove("+"1);
 || b      }

        return list.equalsget("-")0);
    }

public static String eval(String a, String boperator, String operatorb) {
        double r = 0;

        switch (operator) {
            case "/":
                r += Double.parseDouble(a) / Double.parseDouble(b);
                break;
            case "*":
                r += Double.parseDouble(a) * Double.parseDouble(b);
                break;
            case "-":
                r += Double.parseDouble(a) - Double.parseDouble(b);
                break;
            case "+":
                r += Double.parseDouble(a) + Double.parseDouble(b);
                break;
        }

        return Double.toString(r);
    }

These are the results of my tests. The first line is the string inputted, along with the answer to the expression. The second line is the output of the program.

8+4/2+10*3+5*10 = 90
90.0

60*60+8+384/7/4-44*26 = 2477.71
2477.714285714286

64/16*18-51*7+5 = -280
-280.0

64/16*18-5100*7+5 = -35623
-35623.0

7325+92+44/4+57-84 = 7401
7401.0

14+54/9+1 = 21
21.0

7*4/7+9+12*3 = 49
49.0

What can I improve? Is there anything you would recommend me to change?

public String evaluate(String expression) {
    char[] tokens = expression.toCharArray();
    List<String> stack = new ArrayList<>();

    String s = "";

    for (int i = 0; i < tokens.length; i++) {
        if (Character.isDigit(tokens[i])) {
            s += Character.toString(tokens[i]);
        } else {
            stack.add(s);
            stack.add(Character.toString(tokens[i]));
            s = "";
        }

        if (i == tokens.length - 1 && s.length() > 0) {
            stack.add(s);
        }

        if (Character.isDigit(tokens[i]) && stack.size() > 4) {
            String a, b, num1, num2;

            if (i < tokens.length - 1) {
                a = stack.get(stack.size() - 5);
                b = stack.get(stack.size() - 3);
                num1 = stack.get(stack.size() - 4);
                num2 = stack.get(stack.size() - 2);
            } else {
                a = stack.get(stack.size() - 4);
                b = stack.get(stack.size() - 2);
                num1 = stack.get(stack.size() - 3);
                num2 = stack.get(stack.size() - 1);
            }

            if (hasPrecedence(b, a)) {
                stack.set(stack.indexOf(num1), eval(num1, num2, b));
            } else {
                stack.set(stack.indexOf(num1), eval(num1, num2, a));
            }

            stack.remove(stack.lastIndexOf(b));
            stack.remove(stack.lastIndexOf(num2));
        }
    }

    String ans = eval(stack.get(0), stack.get(2), stack.get(1));
    return ans;
}

public boolean hasPrecedence(String a, String b) {
    return (a.equals("*") || a.equals("/")) && (b.equals("+") || b.equals("-"));
}
 
public String eval(String a, String b, String operator) {
    double r = 0;

    switch (operator) {
        case "/":
            r += Double.parseDouble(a) / Double.parseDouble(b);
            break;
        case "*":
            r += Double.parseDouble(a) * Double.parseDouble(b);
            break;
        case "-":
            r += Double.parseDouble(a) - Double.parseDouble(b);
            break;
        case "+":
            r += Double.parseDouble(a) + Double.parseDouble(b);
            break;
    }

    return Double.toString(r);
}

What can I improve? Is there anything you would recommend me to change to optimize my program?

public static String evaluate(String expression) {
        char[] tokens = expression.toCharArray();
        List<String> list = new ArrayList<>();

        String s = "";

        String operator = "";
        String firstNum = "";
        String secondNum = "";

        boolean operationOnQueue = false;

        for (int i = 0; i < tokens.length; i++) {
            if (Character.isDigit(tokens[i])) {
                s += Character.toString(tokens[i]);
            } else {
                list.add(s);
                list.add(Character.toString(tokens[i])); 

                if (operationOnQueue) {
                    operationOnQueue = false;
                    secondNum = s;

                    list.set(list.lastIndexOf(firstNum), eval(firstNum, operator, secondNum));
                    list.remove(list.lastIndexOf(operator));
                    list.remove(list.lastIndexOf(secondNum));
                }

                if (tokens[i] == '*' || tokens[i] == '/') {
                    operationOnQueue = true;

                    operator = Character.toString(tokens[i]);
                    firstNum = list.get(list.lastIndexOf(operator) - 1);
                }

                s = "";
            }

            if (i == tokens.length - 1 && s.length() > 0) {
                list.add(s); 

                if (list.get(list.size() - 2).equals("*") || list.get(list.size() - 2).equals("/")) {
                    firstNum = list.get(list.size() - 3);
                    operator = list.get(list.size() - 2);
                    secondNum = list.get(list.size() - 1);

                    list.set(list.size() - 3, eval(firstNum, operator, secondNum));
                    list.remove(list.size() - 2);
                    list.remove(list.size() - 1);
                }
            }
        }


        while (list.size() > 1) {
            firstNum = list.get(0);
            operator = list.get(1);
            secondNum = list.get(2);

            list.set(0, eval(firstNum, operator, secondNum));
            list.remove(2);
            list.remove(1);
        }

        return list.get(0);
    }

public static String eval(String a, String operator, String b) {
        double r = 0;

        switch (operator) {
            case "/":
                r += Double.parseDouble(a) / Double.parseDouble(b);
                break;
            case "*":
                r += Double.parseDouble(a) * Double.parseDouble(b);
                break;
            case "-":
                r += Double.parseDouble(a) - Double.parseDouble(b);
                break;
            case "+":
                r += Double.parseDouble(a) + Double.parseDouble(b);
                break;
        }

        return Double.toString(r);
    }

These are the results of my tests. The first line is the string inputted, along with the answer to the expression. The second line is the output of the program.

8+4/2+10*3+5*10 = 90
90.0

60*60+8+384/7/4-44*26 = 2477.71
2477.714285714286

64/16*18-51*7+5 = -280
-280.0

64/16*18-5100*7+5 = -35623
-35623.0

7325+92+44/4+57-84 = 7401
7401.0

14+54/9+1 = 21
21.0

7*4/7+9+12*3 = 49
49.0

Tweeted twitter.com/StackCodeReview/status/1153228261012516864

occurred Jul 22, 2019 at 9:00

edited tags

Link

edited Jul 22, 2019 at 4:56

200_success

145.7k
22
191
481

Source Link

asked Jul 22, 2019 at 4:53

rad

61
1
1
5

Loading

Stack Exchange Network

Return to Question