[Swift]LeetCode770. 基本计算器 IV | Basic Calculator IV

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

Given an expression such as expression = "e + 8 - a + 5" and an evaluation map such as {"e": 1} (given in terms of evalvars = ["e"] and evalints = [1]), return a list of tokens representing the simplified expression, such as ["-1*a","14"]

• An expression alternates chunks and symbols, with a space separating each chunk and symbol.
• A chunk is either an expression in parentheses, a variable, or a non-negative integer.
• A variable is a string of lowercase letters (not including digits.) Note that variables can be multiple letters, and note that variables never have a leading coefficient or unary operator like "2x" or "-x".

Expressions are evaluated in the usual order: brackets first, then multiplication, then addition and subtraction. For example, expression = "1 + 2 * 3" has an answer of ["7"].

The format of the output is as follows:

• For each term of free variables with non-zero coefficient, we write the free variables within a term in sorted order lexicographically. For example, we would never write a term like "b*a*c", only "a*b*c".
• Terms have degree equal to the number of free variables being multiplied, counting multiplicity. (For example, "a*a*b*c" has degree 4.) We write the largest degree terms of our answer first, breaking ties by lexicographic order ignoring the leading coefficient of the term.
• The leading coefficient of the term is placed directly to the left with an asterisk separating it from the variables (if they exist.)  A leading coefficient of 1 is still printed.
• An example of a well formatted answer is ["-2*a*a*a", "3*a*a*b", "3*b*b", "4*a", "5*c", "-6"] 
• Terms (including constant terms) with coefficient 0 are not included.  For example, an expression of "0" has an output of [].

Examples:

Input: expression = "e + 8 - a + 5", evalvars = ["e"], evalints = [1]
Output: ["-1*a","14"]

Input: expression = "e - 8 + temperature - pressure",
evalvars = ["e", "temperature"], evalints = [1, 12]
Output: ["-1*pressure","5"]

Input: expression = "(e + 8) * (e - 8)", evalvars = [], evalints = []
Output: ["1*e*e","-64"]

Input: expression = "7 - 7", evalvars = [], evalints = []
Output: []

Input: expression = "a * b * c + b * a * c * 4", evalvars = [], evalints = []
Output: ["5*a*b*c"]

Input: expression = "((a - b) * (b - c) + (c - a)) * ((a - b) + (b - c) * (c - a))",
evalvars = [], evalints = []
Output: ["-1*a*a*b*b","2*a*a*b*c","-1*a*a*c*c","1*a*b*b*b","-1*a*b*b*c","-1*a*b*c*c","1*a*c*c*c","-1*b*b*b*c","2*b*b*c*c","-1*b*c*c*c","2*a*a*b","-2*a*a*c","-2*a*b*b","2*a*c*c","1*b*b*b","-1*b*b*c","1*b*c*c","-1*c*c*c","-1*a*a","1*a*b","1*a*c","-1*b*c"]

Note:

1. expression will have length in range [1, 250].
2. evalvars, evalints will have equal lengths in range [0, 100].

---

给定一个表达式 expression 如 expression = "e + 8 - a + 5" 和一个求值映射，如 {"e": 1}（给定的形式为 evalvars = ["e"] 和 evalints = [1]），返回表示简化表达式的标记列表，例如 ["-1*a","14"]

• 表达式交替使用块和符号，每个块和符号之间有一个空格。
• 块要么是括号中的表达式，要么是变量，要么是非负整数。
• 块是括号中的表达式，变量或非负整数。
• 变量是一个由小写字母组成的字符串（不包括数字）。请注意，变量可以是多个字母，并注意变量从不具有像 "2x" 或 "-x" 这样的前导系数或一元运算符 。

表达式按通常顺序进行求值：先是括号，然后求乘法，再计算加法和减法。例如，expression = "1 + 2 * 3" 的答案是 ["7"]。

输出格式如下：

• 对于系数非零的每个自变量项，我们按字典排序的顺序将自变量写在一个项中。例如，我们永远不会写像 “b*a*c” 这样的项，只写 “a*b*c”。
• 项的次数等于被乘的自变量的数目，并计算重复项。(例如，"a*a*b*c" 的次数为 4。)。我们先写出答案的最大次数项，用字典顺序打破关系，此时忽略词的前导系数。
• 项的前导系数直接放在左边，用星号将它与变量分隔开(如果存在的话)。前导系数 1 仍然要打印出来。
• 格式良好的一个示例答案是 ["-2*a*a*a", "3*a*a*b", "3*b*b", "4*a", "5*c", "-6"] 。
• 系数为 0 的项（包括常数项）不包括在内。例如，“0” 的表达式输出为 []。

示例：

输入：expression = "e + 8 - a + 5", evalvars = ["e"], evalints = [1]
输出：["-1*a","14"]

输入：expression = "e - 8 + temperature - pressure",
evalvars = ["e", "temperature"], evalints = [1, 12]
输出：["-1*pressure","5"]

输入：expression = "(e + 8) * (e - 8)", evalvars = [], evalints = []
输出：["1*e*e","-64"]

输入：expression = "7 - 7", evalvars = [], evalints = []
输出：[]

输入：expression = "a * b * c + b * a * c * 4", evalvars = [], evalints = []
输出：["5*a*b*c"]

输入：expression = "((a - b) * (b - c) + (c - a)) * ((a - b) + (b - c) * (c - a))",
evalvars = [], evalints = []
输出：["-1*a*a*b*b","2*a*a*b*c","-1*a*a*c*c","1*a*b*b*b","-1*a*b*b*c","-1*a*b*c*c","1*a*c*c*c","-1*b*b*b*c","2*b*b*c*c","-1*b*c*c*c","2*a*a*b","-2*a*a*c","-2*a*b*b","2*a*c*c","1*b*b*b","-1*b*b*c","1*b*c*c","-1*c*c*c","-1*a*a","1*a*b","1*a*c","-1*b*c"]

提示：

1. expression 的长度在 [1, 250] 范围内。
2. evalvars, evalints 在范围 [0, 100] 内，且长度相同。

---

同样的测试用例。

使用【测试用例】单独执行，执行正确。

input

"(e + 8) * (e - 8)"
[]
[]

 

Output

["1*e*e","-64"]

 

Expected

["1*e*e","-64"]

但是提交时，提示解答错误。问题不大。

Input

"(e + 8) * (e - 8)"
[]
[]

 

Output

["-63"]

 

Expected

["1*e*e","-64"]

---

class Solution {
    //evaluation map
    static var map:[String:Int] = [String:Int]()   
    
    func basicCalculatorIV(_ expression: String, _ evalvars: [String], _ evalints: [Int]) -> [String] {
        for i in 0..<evalvars.count
        {
            Solution.map[evalvars[i]] = evalints[i]            
        }
        var i:Int = 0
        var l:Int = expression.count
        var stack:[Expression] = [Expression]()
        var priStack:[Int] = [Int]()
        var zero:Expression = Expression(0)
        stack.append(zero)
        priStack.append(0)
        var pri:Int = 0
        
        while (i < l)
        {
            var ch:Character = expression[i]
            if ch.isDigit()
            {
                var num:Int = 0
                while (i < l && expression[i].isDigit())
                {
                    num = num * 10 + (expression[i].ascii - 48)
                    i += 1
                }
                stack.append(Expression(num))
                continue
            }
            if ch.isLetter()
            {
                var s:String = String()
                while (i < l && expression[i].isLetter())
                {
                    s.append(expression[i])
                    i += 1             
                }
                stack.append(Expression(s))
                continue
            }
            if ch == "(" {pri += 2}
            if ch == ")" {pri -= 2}
            if ch == "+" || ch == "-" || ch == "*"
            {
                var nowPri:Int = pri
                if ch == "*" {nowPri += 1}
                while (!priStack.isEmpty && nowPri <= priStack.last!)
                {
                    var now:Expression = stack.removeLast()
                    var last:Expression = stack.removeLast()
                    priStack.removeLast()
                    stack.append(last.cal(now))      
                }
                stack[stack.count - 1].oper = ch
                priStack.append(nowPri)           
            }   
            i += 1   
        }
        
        while (stack.count > 1)
        {
            var now:Expression = stack.removeLast()
            var last:Expression = stack.removeLast()
            stack.append(last.cal(now)) 
        }
        
        return stack.last!.toList()
    }
}

class Term
{
    //the parameter of this term
    var para:Int = 1
    //each factor (e.a. a*b*b*c->{a,b,b,c})    
    var arr:[String] = [String]()       
    
    init(_ x:Int)
    {
        self.para = x
    }
    
    init(_ s:String)
    {
        if Solution.map[s] == nil
        {
            arr.append(s)
        }
        else
        {
            para = Solution.map[s]!
        }
    }
    
    init(_ that:Term)
    {
        self.para = that.para
        self.arr = that.arr     
    }
    
    func toString() -> String
    {
        if para == 0 {return String()}
        var ans:String = String()
        for s in arr
        {
            ans += ("*" + s)
        }
        return String(para) + ans
    }  
    
    func equals(_ that:Term) -> Bool
    {
        if self.arr.count != that.arr.count
        {
            return false
        }
        for i in 0..<self.arr.count
        {
            if self.arr[i] != that.arr[i]
            {
                return false
            }
        }
        return true
    }
    
    func compareTo(_ that:Term) -> Int
    {
        if self.arr.count > that.arr.count {return -1}
        if self.arr.count < that.arr.count {return 1}
        for i in 0..<self.arr.count
        {
            var x:Int = 0
            if self.arr[i] > that.arr[i]
            {
                x = 1
            }
            else if self.arr[i] < that.arr[i]
            {
                x = -1
            }
            else
            {
                x = 0                
            }
            if x != 0 {return x}
        }
        return 0
    }
    
    func times(_ that:Term) -> Term
    {
        var pro = Term(self.para * that.para)
        for s in self.arr 
        {
            pro.arr.append(String(s))
        }
        for s in that.arr
        {
            pro.arr.append(String(s))
        }
        pro.arr = pro.arr.sorted(by:>)
        return pro
    }
}

class Expression
{  
    //Term List
    var list:[Term] = [Term]()
    var oper:Character = "+"   
    
    init(_ x:Int)
    {
        self.list.append(Term(x))
    }
    
    init(_ s:String)
    {
        self.list.append(Term(s))
    } 
    
    init(_ l:[Term])
    {
        self.list = l   
    } 
    
    func times(_ that:Expression) -> Expression
    {
        var c:[Term] = [Term]()
        for t1 in self.list
        {
            for t2 in that.list
            {
                c.append(t1.times(t2))
            }
        }
        c = combine(c)
        return Expression(c)
    }
    
    func plus(_ that:Expression,_ sgn:Int) -> Expression
    {
        var c:[Term] = [Term]()
        for t in self.list
        {
            c.append(Term(t))
        }
        for t in that.list
        {
            var t2:Term = Term(t)
            t2.para = t2.para * sgn
            c.append(t2)                
        }
        c = combine(c)
        return Expression(c)
    }
    
    func cal(_ that:Expression) -> Expression
    {
        if oper == "+"
        {               
            return plus(that,1)
        }
        if oper == "-"
        {
            return plus(that,-1)
        }
        return times(that)
    }
    
    func toList() -> [String]
    {
        var ans:[String] = [String]()
        for t in list
        {
            var s:String = t.toString()
            if s.count > 0 {ans.append(s)}
        }
        return ans
    }
    
    func combine(_ a:[Term]) -> [Term]
    {
        var a = a
        a.sort(by:{(t1:Term,t2:Term) -> Bool in
                   return t1.compareTo(t2) < 0})
        var c:[Term] = [Term]()
        for t in a
        {
            if c.count != 0 && t.equals(c.last!)
            {
                c[c.count - 1].para += t.para
            }
            else
            {
                c.append(Term(t));
            }
        }
        return c
    }
}

//String扩展
extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }    
    
    func isDigit() -> Bool
    {
        if self.ascii > 47 && self.ascii < 58
        {
            return true            
        }
        return false
    }
    
    func isLetter() -> Bool
    {
        if (self.ascii > 64 && self.ascii < 91) || self.ascii > 96 && self.ascii < 123
        {
            return true            
        }
        return false
    }
}