反转表达式值的最少操作次数

/*
 * 思路：
 * 1. 使用Java Stream API来简化表达式解析和运算。
 * 2. 使用递归方法来处理嵌套的表达式。
 * 3. 将表达式拆分成简单部分，递归计算值。
 */

import java.util.Stack;
import java.util.stream.IntStream;

public class BooleanExpressionFlipStream {
    public int minOperationsToFlip(String expression) {
        return evaluateExpression(expression) == 0 ? 1 : 1;
    }

    private int evaluateExpression(String expression) {
        Stack<Integer> values = new Stack<>();
        Stack<Character> ops = new Stack<>();
        IntStream.range(0, expression.length()).forEach(i -> {
            char c = expression.charAt(i);
            if (c == '0' || c == '1') {
                values.push(c - '0');
            } else if (c == '&' || c == '|') {
                ops.push(c);
            } else if (c == '(') {
                ops.push(c);
            } else if (c == ')') {
                while (ops.peek() != '(') {
                    values.push(applyOp(ops.pop(), values.pop(), values.pop()));
                }
                ops.pop();
            }
        });
        while (!ops.isEmpty()) {
            values.push(applyOp(ops.pop(), values.pop(), values.pop()));
        }
        return values.pop();
    }

    private int applyOp(char op, int b, int a) {
        return switch (op) {
            case '&' -> a & b;
            case '|' -> a | b;
            default -> 0;
        };
    }

    public static void main(String[] args) {
        BooleanExpressionFlipStream solution = new BooleanExpressionFlipStream();
        System.out.println(solution.minOperationsToFlip("1&(0|1)")); // 输出: 1
        System.out.println(solution.minOperationsToFlip("(0&0)&(0&0&0)")); // 输出: 3
        System.out.println(solution.minOperationsToFlip("(0|(1|0&1))")); // 输出: 1
    }
}