Given a string of numbers and operators, return all possible results from computing all the different possible ways to group numbers and operators. The valid operators are+ ,- and*.
給定一個數字和運算符的字符串，返回所有不同分組情況下運算的結果。合法的運算符有+，-和*

　　題目的意思就是給一段只有+，-，*的三則運算，然后加括號，加括號的時候符號不變，把加了括號后計算的不同結果列出來

Example 1

Input:"2-1-1".
((2-1)-1) = 0
(2-(1-1)) = 2
Output:[0, 2]

Example 2

Input:"23-45"
(2(3-(45))) = -34
((23)-(45)) = -14
((2(3-4))5) = -10
(2((3-4)5)) = -10
(((23)-4)5) = 10
Output:[-34, -14, -10, -10, 10]

My Solution

(Java) Version 1 Time: 7ms:

　　思考括號的分組情況確實耗費了很長時間，一開始考慮是從數字開始分組，如果數字有奇數(n)個，那么就可以從第一個到第n/2個，分別加上括號，然后遞歸這個情況，知道只有兩個運算數和一個運算符為止，然而，這個分類的方法實現起來相當麻煩，循環的操作十分復雜。然后從這個解法是從運算符開始分組，按照每一個運算符都是分為前一組和后一組，進行遞歸，就簡單多了

public class Solution {
    public List<Integer> diffWaysToCompute(String input) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i); //搜索運算符
            if (c == '+' || c == '-' || c == '*') { //判斷運算符
                String s_bef = input.substring(0, i); //取出前半部分
                String s_aft = input.substring(i + 1, input.length()); //取出后半部分
                List<Integer> l_bef = diffWaysToCompute(s_bef); //遞歸
                List<Integer> l_aft = diffWaysToCompute(s_aft);
                for (Integer a : l_bef) { //雙循環，找到前后遞歸出來的所有數的計算排列
                    for (Integer b : l_aft) {
                        switch (c) {
                        case '+':
                            list.add(a + b);
                            break;
                        case '-':
                            list.add(a - b);
                            break;
                        case '*':
                            list.add(a * b);
                            break;
                        }
                    }
                }
            }
        }
        if (list.size() == 0) { //list.size()為零的時候就是跳出遞歸的時候，這個時候的input就只有一個數
            list.add(Integer.parseInt(input));
        }
        return list;
    }
}