Можно ли построить из заданного набора выражение, равное числу N

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
     int a, b, c, d;
     char x, y, z, e, q, w;
     a = 1;
     b = 2;
     c = 3;
     d = 4;
     int[] arr = new int[4];
        arr[0] = 1;
        arr[1] = 2;
        arr[2] = 3;
        arr[3] = 4;
     char[] charr = new char[6];
        charr[0] = '+';
        charr[1] = '-';
        charr[2] = '/';
        charr[3] = '*';
        charr[4] = '(';
        charr[5] =  ')';
 
            for (int i = 0; i < 4; i++) {
                a = arr[i];
                for (int j = 0; j < 4; j++) {
                    if (i != j) {
                        b = arr[j];
                        for (int k = 0; k < 4; k++) {
                            if (k != j & k != i) {
                                c = arr[k];
                                for (int l = 0; l < 4; l++) {
                                    if (l != j & l != k & l != i) {
                                        d = arr[l];
                                        for (int m = 4; m < 5; m++) {  // цикл символов
                                            for (int n = 0; n < 6; n++) {
                                                if (n != m ) {
                                                    for (int o = 0; o < 6; o++) {
                                                        if (o != n & o != m) {
                                                            for (int p = 0; p < 6; p++) {
                                                                if (p != o & p != n & p != m) {
                                                                    for (int r = 0; r < 6; r++) {
                                                                        if (r != m & r != n & r != o & r != p) {
                                                                            for (int s = 0; s < 6; s++) {
                                                                                if (s != m & s != n & s != o & s != p & s != r) {
                                                                                    System.out.println (charr[s] + a + charr[m]  );
 
 
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
 
 
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    public boolean canBeEqualTo24(int[] nums) throws ScriptException {
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("js");
 
        final int NUMBER_N = 24;
        int number1, number2, number3, number4;
 
        char operator1, operator2, operator3;
 
        int[] arrNums = nums;
 
        char[] arrChs = new char[4];
        arrChs[0] = '*';
        arrChs[1] = '/';
        arrChs[2] = '+';
        arrChs[3] = '-';
 
        String[] arrStr = new String[7];
        for (int i = 0; i < 7; i++) {
            arrStr[i] = "";
            }
        
        String explanation = "Пояснение: из данного набора чисел невозможно составить выражение, равное 24.";
        boolean isEqualTo24 = false;
        Object result = engine.eval("0");
 
        for (int i = 0; i < 4 && !isEqualTo24; i++) {
            number1 = arrNums[i];
            for (int j = 0; j < 4 && !isEqualTo24; j++) {
                if (j != i) {
                    number2 = arrNums[j];
                    for (int k = 0; k < 4 && !isEqualTo24; k++) {
                        if (k != i && k != j) {
                            number3 = arrNums[k];
                            for (int l = 0; l < 4 && !isEqualTo24; l++) {
                                if (l != i && l != j && l != k) {
                                    number4 = arrNums[l];
                                    
                                    for (int m = 0; m < 4 && !isEqualTo24; m++) {
                                        operator1 = arrChs[m];
                                        for (int n = 0; n < 4 && !isEqualTo24; n++) {
                                            operator2 = arrChs[n];
                                            for (int o = 0; o < 4 && !isEqualTo24; o++) {
                                                operator3 = arrChs[o];
                                                
                                                arrStr[0] = "" + number1 + operator1 + number2 + operator2 + number3 + operator3 + number4;
                                                arrStr[1] = "(" + number1 + operator1 + number2 + ")" + operator2 + number3 + operator3 + number4;
                                                arrStr[2] = "(" + number1 + operator1 + number2 + operator2 + number3 + ")" + operator3 + number4;
                                                arrStr[3] = "" + number1 + operator1 + "(" + number2 + operator2 + number3 + ")" + operator3 + number4;
                                                arrStr[4] = "" + number1 + operator1 + "(" + number2 + operator2 + number3 + operator3 + number4 + ")";
                                                arrStr[5] = "" + number1 + operator1 + number2 + operator2 + "(" + number3 + operator3 + number4 + ")";
                                                arrStr[6] = "(" + number1 + operator1 + number2 + ")" + operator2 + "(" + number3 + operator3 + number4 + ")";
 
                                                for (int p = 0; p < 7; p++) {
                                                    result = engine.eval(arrStr[p]);
                                                    if (result.equals(NUMBER_N)) {
                                                        explanation = "Пояснение: " + arrStr[p] + "=24";
                                                        isEqualTo24 = true;
                                                        break;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        System.out.println(explanation);
        return isEqualTo24;
        }

    public static boolean valid(List<List<Double>> list) {
        final List<DoubleBinaryOperator> operators = List.of(
                (a, b) -> a + b, (a, b) -> Math.abs(a - b),
                (a, b) -> a * b, (a, b) -> b != 0 ? a / b : -1.
        );
        final int size = list.get(0).size();
        return (size > 1) ? valid(list.stream()
                .flatMap(l -> IntStream.range(0, size - 1)
                        .boxed()
                        .flatMap(i -> IntStream.range(i + 1, size)
                                .boxed()
                                .flatMap(j -> operators.stream()
                                        .map(op -> op.applyAsDouble(l.get(i), l.get(j)))
                                        .filter(res -> res > 0)
                                        .map(res -> IntStream.range(0, size)
                                                .filter(n -> n != i && n != j)
                                                .mapToObj(l::get)
                                                .collect(collectingAndThen(toList(), r -> {
                                                    r.add(res);
                                                    return r;
                                                }))
                                        )))).collect(toList()))
                : list.stream().anyMatch(i -> i.get(0) == 24.);
    }

    valid(List.of(List.of(4., 1., 8., 7.)))