Можно ли построить из заданного набора выражение, равное числу 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]  );
 
 
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
 
 
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

import java.util.*;
import java.util.List;
 
class Search {
    private static final String[] OPERATORS = {"+", "-", "/", "*"};
    private static final String LABEL_NUMBER = "N";
    private static final String LABEL_OPERATOR = "OP";
 
    private final Statistic statistic;
    private final Map<Integer, Set<String>> resultTree;
 
    Search(int... numbers) {
        this.statistic = new Statistic();
        this.resultTree = this.parse(numbers);
    }
 
    private void checkArgument(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            throw new IllegalArgumentException("Incorrect input argument...");
        }
    }
 
    private String[] intToStringArray(int... numbers) {
        String[] stringInts = new String[numbers.length];
        for (int index = 0; index < numbers.length; index++) {
            stringInts[index] = String.valueOf(numbers[index]);
        }
        return stringInts;
    }
 
    private Map<Integer, Set<String>> parse(int... numbers) {
        long start = System.currentTimeMillis();
        checkArgument(numbers);
        this.statistic.setNumbers(numbers);
 
        List<String> combinationNumbers = recursionCombinations(new ArrayList<>(), intToStringArray(numbers),
                "", false, numbers.length);
        this.statistic.setCombinationsNumbers(combinationNumbers.size());
 
        List<String> combinationOperators = recursionCombinations(new ArrayList<>(), OPERATORS,
                "", true, numbers.length - 1);
        this.statistic.setCombinationsOperators(combinationOperators.size());
 
        List<String> combinationsSolutions = recursionCombinations(new ArrayList<>(), numbers.length - 1,
                numbers.length, "", 2);
        this.statistic.setCombinationsPolish(combinationsSolutions.size());
 
        List<Stack<String>> shareCombinations = getAllCombinations(combinationNumbers, combinationOperators, combinationsSolutions);
        this.statistic.setShareCombinations(shareCombinations.size());
 
        Map<Integer, Set<String>> tree = getFullSolutions(shareCombinations, intToStringArray(numbers));
 
        this.statistic.setTimeMS(System.currentTimeMillis() - start);
        return tree;
    }
 
    private List<String> recursionCombinations(List<String> list, String[] array, String line, boolean duplicate, int length) {
        if (list != null && array != null && line != null) {
            if (length == 0) {
                line = line.trim();
                if (!line.isEmpty()) {
                    list.add(line.trim());
                }
            } else {
                for (int index = 0; index < array.length; index++) {
                    String[] nextArray = duplicate ? array : removeElementToArray(array, index);
                    String nextLine = line.concat(" ").concat(array[index]);
                    list = recursionCombinations(list, nextArray, nextLine, duplicate, length - 1);
                }
            }
        }
        return list;
    }
 
    private String[] removeElementToArray(String[] array, int index) {
        String[] result = null;
        if (array != null && array.length > 0) {
            result = array.clone();
            if (index < result.length - 1) {
                System.arraycopy(result, index + 1, result, index, result.length - index - 1);
            }
            result = Arrays.copyOf(result, result.length - 1);
        }
        return result;
    }
 
    private List<Stack<String>> getAllCombinations(List<String> numbers, List<String> operators, List<String> variants) {
        List<Stack<String>> list = new ArrayList<>();
        for (String variant : variants) {
            for (String operator : operators) {
                String[] arrayO = operator.split("\\s");
                for (String number : numbers) {
                    String[] arrayN = number.split("\\s");
                    Stack<String> stack = new Stack<>();
                    int o = 0;
                    int n = 0;
                    for (String element : variant.split("\\s")) {
                        if (element.equals(LABEL_NUMBER)) {
                            stack.push(arrayN[n++]);
                        } else {
                            stack.push(arrayO[o++]);
                        }
                    }
                    list.add(stack);
                }
            }
        }
        return list;
    }
 
    private String getDuplicateString(String str, int amount) {
        String result = "";
        for (int count = 0; count < amount; count++) {
            result = result.concat(str);
        }
        return result;
    }
 
    private List<String> recursionCombinations(List<String> list, int operators, int numbers, String line, int min) {
        if (numbers == min) {
            line = getDuplicateString(LABEL_NUMBER, numbers).
                    concat(getDuplicateString(LABEL_OPERATOR, operators)).concat(line);
 
            line = line.replaceAll(LABEL_OPERATOR, LABEL_OPERATOR.concat(" ")).
                    replaceAll(LABEL_NUMBER, LABEL_NUMBER.concat(" ")).trim();
            list.add(line);
        } else if (numbers > min) {
            String next;
            int end = line.length() == 0 ? 1 : 0;
            for (int count = operators; count >= end; count--) {
                next = LABEL_NUMBER.concat(getDuplicateString(LABEL_OPERATOR, count)).concat(line);
                list = recursionCombinations(list, operators - count, numbers - 1, next, min);
            }
        }
        return list;
    }
 
    private boolean isNumber(String line) {
        return line.matches("[+-]*\\d+");
    }
 
    private Integer getResult(int first, int second, String operator) {
        Integer result = null;
        switch (operator) {
            case "+":
                result = first + second;
                break;
            case "-":
                result = first - second;
                break;
            case "*":
                result = first * second;
                break;
            case "/":
                if (second != 0 && first % second == 0) {
                    result = first / second;
                }
                break;
            default:
                result = first;
        }
        return result;
    }
 
    private int getPriority(String line) {
        int priority = 0;
        for (String element : line.split("\\s")) {
            if (!element.matches("[-]*\\d+")) {
                priority = element.equals("*") || element.equals("/") ? 2 : 1;
            }
        }
        return priority;
    }
 
    private String getString(String first, String second, String operator) {
        int priority = getPriority(operator);
        first = !isNumber(first) ? priority > getPriority(first) ? "(".concat(first).concat(")") : first : first;
        second = !isNumber(second) ? priority > getPriority(second) ? "(".concat(second).concat(")") : second : second;
        return first.concat(" " + operator + " ").concat(second);
    }
 
    private Map<Integer, Set<String>> getFullSolutions(List<Stack<String>> list, String[] numbers) {
        Map<Integer, Set<String>> tree = new TreeMap<>();
        if (numbers.length == 1) {
            Integer number = Integer.parseInt(numbers[0]);
            tree.put(number, new HashSet<>());
            tree.get(number).add(numbers[0]);
        } else {
            for (Stack<String> stack : list) {
                Stack<Integer> result = new Stack<>();
                Stack<String> line = new Stack<>();
                for (String element : stack) {
                    if (isNumber(element)) {
                        result.push(Integer.parseInt(element));
                        line.push(element);
                    } else {
                        if (result.size() >= 2) {
                            int second = result.pop();
                            int first = result.pop();
                            String two = line.pop();
                            String one = line.pop();
                            String formula = getString(one, two, element);
                            line.push(formula);
                            Integer solution = getResult(first, second, element);
                            if (solution != null) {
                                result.push(solution);
                            } else {
                                result.clear();
                                line.clear();
                                break;
                            }
                        } else {
                            result.clear();
                            line.clear();
                            break;
                        }
                    }
                }
 
                if (result.size() == 1 && line.size() == 1) {
                    Integer answer = result.pop();
                    if (!tree.containsKey(answer)) {
                        tree.put(answer, new HashSet<>());
                    }
                    tree.get(answer).add(line.pop());
                }
            }
        }
        return tree;
    }
 
    boolean checkAnswer(int answer) {
        return this.resultTree.containsKey(answer);
    }
 
    Set<String> getSolutionByAnswer(int answer) {
        return checkAnswer(answer) ? this.resultTree.get(answer) : new HashSet<>();
    }
 
    @Override
    public String toString() {
        return this.statistic.toString();
    }
 
    private class Statistic {
        private long timeMS;
        private int[] numbers;
        private int combinationsNumbers;
        private int combinationsOperators;
        private int combinationsPolish;
        private int shareCombinations;
 
        void setNumbers(int[] numbers) {
            this.numbers = numbers;
        }
 
        void setCombinationsNumbers(int combinationsNumbers) {
            this.combinationsNumbers = combinationsNumbers;
        }
 
        void setCombinationsOperators(int combinationsOperators) {
            this.combinationsOperators = combinationsOperators;
        }
 
        void setTimeMS(long timeMS) {
            this.timeMS = timeMS;
        }
 
        void setCombinationsPolish(int combinationsPolish) {
            this.combinationsPolish = combinationsPolish;
        }
 
        void setShareCombinations(int shareCombinations) {
            this.shareCombinations = shareCombinations;
        }
 
        private String parseLongToString() {
            return String.format("%d sec. %d ms", this.timeMS / 1_000, this.timeMS % 1000);
        }
 
        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append(String.format("%30s", "STATISTIC")).append("\n");
            sb.append(String.format("%-30s %s;", "Numbers:", Arrays.toString(this.numbers))).append("\n");
            sb.append(String.format("%-30s %d;", "Combinations numbers:", this.combinationsNumbers)).append("\n");
            sb.append(String.format("%-30s %d;", "Combinations operators:", this.combinationsOperators)).append("\n");
            sb.append(String.format("%-30s %d;", "Combinations brackets:", this.combinationsPolish)).append("\n");
            sb.append(String.format("%-30s %d;", "Share amount combinations:", this.shareCombinations)).append("\n");
            sb.append(String.format("%-30s %s;", "Spent time:", parseLongToString())).append("\n");
            return sb.toString();
        }
    }
}
 
class SearchTest {
    public static void main(String[] args) {
        Search search = new Search(4, 1, 8, 7);
 
        //выводим статистику парсинга
        System.out.println(search);
 
        System.out.println("Есть ли ответ 24?: " + search.checkAnswer(24) + ";");
 
        //получаем все варианты для ответа 24
        Set<String> answers = search.getSolutionByAnswer(24);
        System.out.println("Ответ 24:");
        for (String line : answers) {
            System.out.println("    " + line + ";");
        }
    }
}

                     STATISTIC
Numbers:                       [4, 1, 8, 7];
Combinations numbers:          24;
Combinations operators:        64;
Combinations brackets:         6;
Share amount combinations:     9216;
Spent time:                    1 sec. 32 ms;
 
Есть ли ответ 24?: true;
Ответ 24:
    8 / 1 * (7 - 4);
    8 * (7 * 1 - 4);
    8 * (1 * (7 - 4));
    8 * (1 * 7 - 4);
    1 * (7 - 4) * 8;
    8 * (7 - 4) * 1;
    (7 - 4) * 8 / 1;
    8 * 4 - 7 + 1;
    (7 + 1) * 4 - 8;
    8 * 7 - 1 * 4;
    4 * 8 - 7 - 1;
    (1 + 7) * 4 - 8;
    (8 * (7 - 4)) / 1;
    8 * 1 * (7 - 4);
    4 * 8 - 7 + 1;
    1 * 8 * (7 - 4);
    8 * (7 - 4) / 1;
    (7 - 4) * 8 * 1;
    7 - 1 * 4 * 8;
    (8 * (7 - 4)) * 1;
    8 * 4 - 7 - 1;
    4 * 8 - 1 - 7;
    8 * 4 - 1 + 7;
    (7 - 1) * (8 - 4);
    8 * (7 / 1 - 4);
    8 * 4 - 1 - 7;
    (1 * (7 - 4)) * 8;
    4 * 8 - 1 + 7;
    8 * 7 - 4 / 1;
    7 - 4 / 1 * 8;
    (7 * 1 - 4) * 8;
    (4 - 8) * (1 - 7);
    (7 / 1 - 4) * 8;
    (8 - 4) * (7 - 1);
    (7 - 4) / 1 * 8;
    (1 * 7 - 4) * 8;
    (1 - 7) * (4 - 8);
    1 * (8 * (7 - 4));
    4 * (7 + 1) - 8;
    4 * (1 + 7) - 8;
    (7 - 4) * 1 * 8;
    7 - 4 * 1 * 8;
    8 * 7 - 4 * 1;
 
Process finished with exit code 0

 Object o = "24.0";//как у тебя  в примере 
        String r = o.toString();
        r = r.substring(0, 2);
        System.out.println(r);