Generating random equations with wrong answers ( operator precedence problem )

I am trying to generate a random Equation and an answer to it.
Everything works fine, except the answers are being calculated wrong ( without consideration of operator precedence ). I've been trying to fix it for some time now, and i have a general idea of how to approach it, but i have no idea how to actually do it, and there is little to no information on it on the web.

Here is my code:

    public static Equation randomEquation() {
Random random = new Random();
int numNumbers = random.nextInt(3) + 2; // generate between 2 and 4 numbers
List<Integer> numbers = new ArrayList<>();
for (int i = 0; i < numNumbers; i++) {
int number = random.nextInt(101); // generate random number between 0 and 100
numbers.add(number);
}
StringBuilder equationBuilder = new StringBuilder();
int answer = numbers.get(0);
equationBuilder.append(numbers.get(0));
for (int i = 1; i < numNumbers; i++) {
int operator = random.nextInt(4); // generate random operator: 0 for addition, 1 for subtraction, 2 for multiplication, 3 for division
int number;
if (operator == 2) {
// Limit multiplication operation to never generate a result more than 10
do {
number = random.nextInt(11);
} while (number == 0);
} else {
number = random.nextInt(101); // generate random number between 0 and 100
}
switch (operator) {
case 0 -> {
equationBuilder.append(" + ");
answer += number;
}
case 1 -> {
equationBuilder.append(" - ");
answer -= number;
}
case 2 -> {
equationBuilder.append(" * ");
answer *= number;
}
case 3 -> {
equationBuilder.append(" / ");
if (number == 0 || answer % number != 0) {
// If the second number is 0 or the division results in a non-integer answer, regenerate the equation
return randomEquation();
} else {
answer /= number;
}
}
}
equationBuilder.append(number);
}
String equation = equationBuilder.toString();
return new Equation(equation, answer);
}

So there is clearly a problem with how the answer is calculated in here:

switch (operator) {
case 0 -> {
equationBuilder.append(" + ");
answer += number;
}
case 1 -> {
equationBuilder.append(" - ");
answer -= number;
}
case 2 -> {
equationBuilder.append(" * ");
answer *= number;
}
case 3 -> {
equationBuilder.append(" / ");
if (number == 0 || answer % number != 0) {
// If the second number is 0 or the division results in a non-integer answer, regenerate the equation
return randomEquation();
} else {
answer /= number;
}
}
}

I am simply appending the answer with every number, which does not make sense when multiplying and dividing.

So my question is, how do i introduce the concept of operator precedence into my code?

To account for operator precedence, don't think of an equation as "a list of numbers separated as operators". Instead, think of it as a tree.

Define a EquationComponent, which can be either:

• a constant number, or
• an operation (plus, minus, times, divide) on two other EquationComponents

This kind of sealed hierarchy can be implemented by a sealed interface/class. If your version of Java doesn't have that, a regular interface is fine too.

The special thing that an EquationComponent can do, is it has a value, or as you'd like to call it, an "answer".

To get an "answer" from a constant number, just return that number. To get an "answer" from an operation, first get the "answers" from the two sides of the operation, and apply the operator to the two values.

When we convert an EquationComponent to string, we always add parentheses around it. And because the "answer" is calculated based on the equation components, this makes sure that the answer is always consistent with how the equation is displayed.

Here is an example implementation. Pay attention to how toString and getAnswer are implemented.

enum Operation {
PLUS("+"),
MINUS("-"),
TIMES("*"),
DIVIDE("/");
private final String symbol;
Operation(String symbol) {
this.symbol = symbol;
}
@Override
public String toString() {
return symbol;
}
}
sealed interface EquationComponent permits Equation, ConstantNumber {
int getAnswer();
}
final class ConstantNumber implements EquationComponent {
private final int number;
// getters, equals, hashCode if you need those...
public ConstantNumber(int number) {
this.number = number;
}
@Override
public String toString() {
return Integer.toString(number);
}
@Override
public int getAnswer() {
return number;
}
}
final class Equation implements EquationComponent {
private final EquationComponent left;
private final EquationComponent right;
private final Operation operation;
// getters, equals, hashCode if you need those...
public Equation(EquationComponent left, EquationComponent right, Operation operation) {
this.left = left;
this.right = right;
this.operation = operation;
}
// I'm using string concatenation here just for convenience,
// you can totally change this to use StringBuilder instead.
@Override
public String toString() {
// note that this adds parentheses to every operation
return "(" + left + " " + operation + " " + right + ")";
}
@Override
public int getAnswer() {
// this could be cached somewhere...
return switch (operation) {
case PLUS -> left.getAnswer() + right.getAnswer();
case MINUS -> left.getAnswer() - right.getAnswer();
case TIMES -> left.getAnswer() * right.getAnswer();
// integer division?
case DIVIDE -> left.getAnswer() / right.getAnswer();
};
}
}

Now we have the infrastructure, we can start generating equations. Instead of deciding how many numbers you are going to generate. Decide how many operations you are going to generate.

Write a method that generates an operation. This method will choose an operator, and then for the left and right side of it, call itself recursively to generate more operations, or constant numbers if the maximum number of operations is already generated.

private static int remainingOperations;
private static final Random r = new Random();
public static void main(String[] value) throws IOException {
remainingOperations = r.nextInt(1, 4); // 1 to 3 operations
EquationComponent eq = makeEquation();
System.out.println(eq);
System.out.println(eq.getAnswer());
}
private static EquationComponent makeEquation() {
if (remainingOperations > 0) {
remainingOperations--;
// even if your version of Java doesn't have switch expressions
// it should be obvious what this does and converting it to a switch
// statement is trivial.
Operator op = switch (r.nextInt(4)) {
case 0 -> Operator.PLUS;
case 1 -> Operator.MINUS;
case 2 -> Operator.TIMES;
default -> Operator.DIVIDE;
};
if (op == Operator.TIMES) {
return new Operation(
// the left could be another number
r.nextBoolean() ? makeEquation() : makeNumber(101),
// generate a small number on the right if it is multiplication
makeNumber(11),
op
);
} else {
// this allows both sides to be a constant number,
// which means we could generate an equation with fewer
// operations than remainingOperations
return new Operation(
// the left could be another number
r.nextBoolean() ? makeEquation() : makeNumber(101),
// the right could be another number
r.nextBoolean() ? makeEquation() : makeNumber(101),
op
);
}
} else {
return makeNumber(101);
}
}
private static ConstantNumber makeNumber(int limit) {
return new ConstantNumber(r.nextInt(limit));
}

Since the operator is generated randomly, you'll have to evaluate the equationBuilder string, after its generation.

In this example I utilized the Pattern and Matcher classes to isolate the operation indices, using a regular expression pattern.

static int answer(String string) {
    Pattern pattern = Pattern.compile("(-?\\d+) \\* (-?\\d+)");
    Matcher matcher;
    int operandA, operandB, result;
    while ((matcher = pattern.matcher(string)).find()) {
        operandA = Integer.parseInt(matcher.group(1));
        operandB = Integer.parseInt(matcher.group(2));
        result = operandA * operandB;
        string = string.replace(matcher.group(), String.valueOf(result));
    }
    pattern = Pattern.compile("(-?\\d+) / (-?\\d+)");
    while ((matcher = pattern.matcher(string)).find()) {
        operandA = Integer.parseInt(matcher.group(1));
        operandB = Integer.parseInt(matcher.group(2));
        result = operandA / operandB;
        string = string.replace(matcher.group(), String.valueOf(result));
    }
    pattern = Pattern.compile("(-?\\d+) ([-+]) (-?\\d+)");
    while ((matcher = pattern.matcher(string)).find()) {
        operandA = Integer.parseInt(matcher.group(1));
        operandB = Integer.parseInt(matcher.group(3));
        result = switch (matcher.group(2)) {
            case "+" -> operandA + operandB;
            default -> operandA - operandB;
        };
        string = string.replace(matcher.group(), String.valueOf(result));
    }
    return Integer.parseInt(string);
}

And, I modified your operator assignment code-block, with the following.

switch (operator) {
    case 0 -> equationBuilder.append(" + ");
    case 1 -> equationBuilder.append(" - ");
    case 2 -> equationBuilder.append(" * ");
    case 3 -> {
        equationBuilder.append(" / ");
        if (number == 0 || answer % number != 0) {
            // If the second number is 0 or the division results in a non-integer answer, regenerate the equation
            return randomEquation();
        }
    }
}

And, subsequently, returned this as the value.

return new Equation(equation, answer(equation));

Here are a few examples.

6 * 5 - 34 - 59 = -63
8 * 1 = 8
5 * 7 = 35
71 - 22 = 49
43 - 52 = -9

Additionally, I added some println calls to the while-loops, to display the procedures.

15 * 5
15 * 5 = 75
100 + 47 - 40 + 67
100 + 47 = 147
147 - 40 = 107
107 + 67 = 174
87 / 1 * 4
1 * 4 = 4
87 / 4 = 21
22 * 6 - 37
22 * 6 = 132
132 - 37 = 95
17 - 44 + 45 * 6
45 * 6 = 270
17 - 44 = -27
-27 + 270 = 243

Furthermore, you could improve this code by utilizing a double, and adjusting the regular expression to match real numbers.

Or even, utilize the BigDecimal class to evaluate numbers outside of the 64-bit range.