[Swift]LeetCode241. 为运算表达式设计优先级 | Different Ways to Add Parentheses

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10205235.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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"
Output: [0, 2]
Explanation: 
((2-1)-1) = 0 
(2-(1-1)) = 2

Example 2:

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

---

给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。

示例 1:

输入: "2-1-1"
输出: [0, 2]
解释: 
((2-1)-1) = 0 
(2-(1-1)) = 2

示例 2:

输入: "2*3-4*5"
输出: [-34, -14, -10, -10, 10]
解释: 
(2*(3-(4*5))) = -34 
((2*3)-(4*5)) = -14 
((2*(3-4))*5) = -10 
(2*((3-4)*5)) = -10 
(((2*3)-4)*5) = 10

---

12ms

class Solution {
    
    var c = [String : [Int]]()
    func diffWaysToCompute(_ input: String) -> [Int] {
        let sp = Array(input)
        let result = getResult(sp)
        return result
    }
    
    func getResult(_ s:[Character]) -> [Int] {
        if let arr = c[String(s)] {
            return arr
        }
        var ans = [Int]()
        for i in 0 ..< s.count {
            if s[i] == "+" || s[i] == "-" || s[i] == "*" {
                let left = Array(s.prefix(upTo: i))
                let right = Array(s.suffix(from: i+1))
                let l = getResult(left)
                let r = getResult(right)
                
                for a in l {
                    for b in r {
                        if s[i] == "+" {
                            ans.append(a + b)
                        } else if s[i] == "-" {
                            ans.append(a - b)
                        } else if s[i] == "*" {
                            ans.append(a * b)
                        }
                    }
                }                
            }
        }
        if ans.isEmpty {
            var val : Int = 0
            for dig in s {
                val = val * 10 + Int(dig.unicodeScalars.first!.value - "0".unicodeScalars.first!.value)
            }
            ans.append(val)
        }
        c[String(s)] = ans
        return ans
    }
}

---

24ms

class Solution {
    func diffWaysToCompute(_ input: String) -> [Int] {

        var res = [Int]()
        for (i, c) in input.enumerated(){
            if c == "+" || c == "-" || c == "*" {
                var left = diffWaysToCompute(input.substring(0, i))
                var right = diffWaysToCompute(input.substring(i+1))
                for j in left.indices {
                    for k in right.indices {
                        if c == "+" { res.append(left[j] + right[k])}
                        if c == "-" { res.append(left[j] - right[k])}
                        if c == "*" { res.append(left[j] * right[k])}
                    }
                }
            }
        }
               
        if res.isEmpty { res.append(Int(input)!) }
        return res
    }
}

extension String {
    func substring(_ i: Int, _ len: Int = -1) -> String {
        var startInd = index(startIndex, offsetBy: i)
        var endInd = endIndex
        if len != -1 { endInd = index(startIndex, offsetBy: i+len) }
        return String(self[startInd..<endInd])
    }
}

---

24ms

class Solution {
    func diffWaysToCompute(_ input: String) -> [Int] {
        let sarr = Array(input)
        var res = [Int]()
        for i in 0..<sarr.count {
            let c = sarr[i]
            if c == "+" || c == "-" || c == "*" {
                let res1 = diffWaysToCompute(String(sarr[0..<i]))
                let res2 = diffWaysToCompute(String(sarr[i+1..<sarr.count]))
                for r1 in res1 {
                    for r2 in res2 {
                        if c == "+" {
                            res.append(r1 + r2)
                        }else if c == "-" {
                            res.append(r1 - r2)
                        }else if c == "*" {
                            res.append(r1 * r2)
                        }
                    }
                }
            }
        }
        if res.isEmpty {
            res.append(Int(input)!)
        }
        return res
    }
}

---

44ms

class Solution {
    let operators : [Character] = ["+","-","*"]
    func diffWaysToCompute(_ input: String) -> [Int] {
        var result : [Int] = []
        var index : String.Index = input.startIndex
        while index != input.endIndex  {
            if operators.contains(input[index]){
                let resultLeft = diffWaysToCompute(String(input[..<index]))
                let resultRight = diffWaysToCompute(String(input[input.index(after: index)...]))
                for leftNum in resultLeft {
                    for rightNum in resultRight {
                        switch input[index] {
                        case "+":
                            result.append(leftNum+rightNum)
                        case "-":
                            result.append(leftNum-rightNum)
                        case "*":
                            result.append(leftNum*rightNum)
                        default:
                            break
                        }
                    }
                }
            }
            index = input.index(after: index)
        }
        if result.isEmpty {
            result.append(Int(input) ?? 0)
        }
        
        return result
    }
}