java - 使用数组时的数学表达式 (Java)

Question

问题如下:我需要制作一个 Java 程序，为您提供随机数(例如 1 2 3)，然后需要提供随机运算符(例如 + *)。

嗯，我已经得到了那部分，但是我如何使用 Java 代码检查该答案。答案应该是7。

以下代码是问题所在:

    String operations[] = {"+ ","- ","* ","/ "};
    System.out.println("How many digits?");
    int times = scan.nextInt();
    this.times = times;
    this.operation = new String[times-1];
    this.digits = new int[times];

    for (int i = 0; i < times - 1; i++)
    {
        operation[i] = operations[rand.nextInt(4)];
        System.out.print(operation[i]);
    }

    for(int i = 0; i < operation.length; i++)
    {
        System.out.print(digits[i]+" ");
        System.out.println(digits[i] + operation[i] + digits[i]);         //first digit + - * / the first digit
    }

希望这些片段是清楚的。我想做的是获得随机数字和运算符。之后我想运行该表达式。

希望你能帮助我。

Answer 1

与当前此处的任何其他答案不同，这是允许多个操作数并尊重操作顺序的答案。

import java.util.Arrays;
import java.util.List;

public class Expression {
    private List<Integer> operands;
    private List<Character> operators;

    public Expression(List<Integer> operands, List<Character> operators) {
        this.operands = operands;
        this.operators = operators;
    }

    public Expression subExpression(int fromIndex, int toIndex) {
        return new Expression(
                operands.subList(fromIndex, toIndex), 
                operators.subList(fromIndex, toIndex - 1));
    }

    private int rightMost(char operator) {
        return operators.lastIndexOf(operator);
    }

    public double evaluate() {
        if (operands.size() == 1) {
            return operands.get(0).doubleValue();
        }

        if (rightMost('+') > -1){
            return subExpression(0, rightMost('+') + 1).evaluate()
                + subExpression(rightMost('+') + 1, operands.size()).evaluate();  
        }
        if (rightMost('-') > -1){
            return subExpression(0, rightMost('-') + 1).evaluate() 
                - subExpression(rightMost('-') + 1, operands.size()).evaluate();  
        }
        if (rightMost('*') > -1){
            return subExpression(0, rightMost('*') + 1).evaluate() 
                * subExpression(rightMost('*') + 1, operands.size()).evaluate();  
        }
        if (rightMost('/') > -1){
            return subExpression(0, rightMost('/') + 1).evaluate() 
                / subExpression(rightMost('/') + 1, operands.size()).evaluate();  
        }
        return 0;
    }

    @Override
    public String toString() {
        StringBuilder toReturn = new StringBuilder();
        for (int index = 0; index < operands.size(); index++){
        toReturn.append(operands.get(index));
        toReturn.append(" ");
        toReturn.append(
                index == operators.size() ? "=" : operators.get(index));
        toReturn.append(" ");
       }
       toReturn.append(evaluate());
       return toReturn.toString();
    }

    public static Expression makeRandom(
        int minimum, int maximum, int numberOfOperands) {
        Integer[] operands = new Integer[numberOfOperands];
        Character[] operators = new Character[numberOfOperands - 1];
        for (int index = 0; index < numberOfOperands; index++) {
            operands[index] = minimum 
                        + (int)(Math.random() * (maximum - minimum + 1));
        }
        for (int index = 0; index < numberOfOperands - 1; index++) {
            operators[index] = "+-*/".charAt((int)(Math.random() * 4));
        }
        return new Expression(Arrays.asList(operands), Arrays.asList(operators));
    }

    public static void main (String[] args){
        System.out.println(makeRandom(1, 10, 6));
        System.out.println(new Expression(
                Arrays.asList(1, 2, 3), Arrays.asList('+', '*')));
    }
}

main 只是在这里进行快速而肮脏的测试。这是一次运行的输出。正如您所看到的，1 + 2 * 3 给出了正确的答案 - 当前此页面上没有其他答案可以得出正确的答案。

10 / 5 / 6 * 9 + 9 * 1 = 12.0
1 + 2 * 3 = 7.0

我已经让evaluate返回double以避免整数除法带来任何令人讨厌的意外。如果需要的话，这可以很容易地改变。另外，这里没有错误处理 - 有一些方法应该对其参数进行一些错误处理，并且确实应该做一些关于捕获被零除的事情。

其工作原理是将表达式拆分为更小的子表达式，递归地计算每个子表达式，然后将它们重新组合在一起。神奇之处在于 evaluate 方法中的操作顺序。由于这些原因，必须按此顺序处理不同的运算符。

• + 必须在 - 之前考虑，以便 a - b + c 解析为 (a - b) + c，而不是a - (b + c)。
• * 必须在 / 之前考虑，以便 a/b * c 解析为 (a/b) * c，而不是a/(b * c)。
• + 和 - 都必须在 * 和 / 之前考虑，这样 *首先评估 和 /。
• 减法必须从右向左进行，以便 a - b - c 解析为 (a - b) - c，而不是 a - ( b - c)。
• 除法必须从右向左进行，以便 a/b/c 解析为 (a/b)/c，而不是 a/( b/c)。
• 加法和乘法可以从左到右或从右到左进行，但编写了 rightMost 方法后，从右到左进行加法和乘法是有意义的。