Задача на рекурсию

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.LineNumberReader;
import java.util.ArrayList;
import java.util.LinkedList;
 
public class Marthians {
 
    public static void main(String[] args) {
        File file = new File("INPUT.txt");
        File fout = new File("OUTPUT.txt");
        if (fout.exists()) {
            fout.delete();
            try {
                fout.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        FileWriter wout = null;
        try {
            wout = new FileWriter(fout);
        } catch (IOException e1) {
            e1.printStackTrace();
        }
        LineNumberReader lnr = null;
        try {
            lnr = new LineNumberReader(new FileReader(file));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        String line;
        MarsExec marsExec;
        try {
            while ((line = lnr.readLine()) != null) {
                marsExec = new MarsExec(line);
                wout.write(line + " " + marsExec.findResult());
                wout.write(" ");
            }
            wout.write("\n");
            wout.flush();
            wout.close();
        } catch (IOException e) {
            e.printStackTrace();
        }       
    }
 
    private static class MarsExec {
        private String unparsedLine;
        private Integer expectResult;
        private ArrayList<String> operations = new ArrayList<String>();
 
        private static char signList[] = { '+', '-', '*' };
 
        public MarsExec(String line) {
            this.unparsedLine = line.split("=")[1];
            this.expectResult = Integer.parseInt(line.split("=")[0]);
        }
 
        public String findResult() {
            String result = "-1";
            String[] digitsWithSquares = unparsedLine.split(" ");
            int len = digitsWithSquares.length - 1;
            operations.clear();
            StringBuffer sb = new StringBuffer(len);
            char currentChar = signList[0];
            for (int i = 1; i <= len; i++) {
                sb.append(currentChar);
            }
            changeCharacters(0, sb, len);
            String[] workOperators;
            String executeLine;
            for (String currentOperators : operations) {
                workOperators = currentOperators.split("");
                executeLine = createExecuteLine(workOperators, digitsWithSquares);
//              System.out.println("execline " + executeLine);
                if (expectResult == eval(executeLine)) {
                    result = expectResult + "=" + executeLine;
                    break;
                }
            }
            return result;
        }
 
        private String createExecuteLine(String[] workOperators, String[] digitsWithSquares) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < workOperators.length; i++) {
                sb.append(workOperators[i]);
                sb.append(digitsWithSquares[i]);
            }
            return sb.toString();
        }
 
        boolean isOperator(char c) {
            return c == '+' || c == '-' || c == '*';
        }
 
        int priority(char op) {
            switch (op) {
            case '+':
            case '-':
            case '*':
                return 1;
            default:
                return -1;
            }
        }
 
        boolean isDelim(char c) {
            return c == ' ';
        }
 
        void processOperator(LinkedList<Integer> st, char op) {
            int r = st.removeLast();
            int l = st.removeLast();
            switch (op) {
            case '+':
                st.add(l + r);
                break;
            case '-':
                st.add(l - r);
                break;
            case '*':
                st.add(l * r);
                break;
            }
        }
 
        private int eval(String s) {
            LinkedList<Integer> st = new LinkedList<Integer>();
            LinkedList<Character> op = new LinkedList<Character>();
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (isDelim(c))
                    continue;
                if (c == '(')
                    op.add('(');
                else if (c == ')') {
                    while (op.getLast() != '(')
                        processOperator(st, op.removeLast());
                    op.removeLast();
                } else if (isOperator(c)) {
                    while (!op.isEmpty() && priority(op.getLast()) >= priority(c))
                        processOperator(st, op.removeLast());
                    op.add(c);
                } else {
                    String operand = "";
                    while (i < s.length() && Character.isDigit(s.charAt(i)))
                        operand += s.charAt(i++);
                    --i;
                    st.add(Integer.parseInt(operand));
                }
            }
            while (!op.isEmpty())
                processOperator(st, op.removeLast());
            return st.get(0);
        }
 
        private StringBuffer changeCharacters(int pos, StringBuffer sb, int length) {
            for (int i = 0; i <= signList.length - 1; i++) {
                sb.setCharAt(pos, signList[i]);
                if (pos == length - 1) {
                    operations.add(sb.toString());
                } else {
                    changeCharacters(pos + 1, sb, length);
                }
            }
            return sb;
        }
    }
}