LeetCode-Python-439. 三元表达式解析器

给定一个以字符串表示的任意嵌套的三元表达式，计算表达式的值。你可以假定给定的表达式始终都是有效的并且只包含数字 0-9, ?, :, T 和 F (T 和 F 分别表示真和假）。

注意：

给定的字符串长度 ≤ 10000。
所包含的数字都只有一位数。
条件表达式从右至左结合（和大多数程序设计语言类似）。
条件是 T 和 F其一，即条件永远不会是数字。
表达式的结果是数字 0-9, T 或者 F。
 

示例 1：

输入： "T?2:3"

输出： "2"

解释： 如果条件为真，结果为 2；否则，结果为 3。
 

示例 2：

输入： "F?1:T?4:5"

输出： "4"

解释： 条件表达式自右向左结合。使用括号的话，相当于：

             "(F ? 1 : (T ? 4 : 5))"                   "(F ? 1 : (T ? 4 : 5))"
          -> "(F ? 1 : 4)"                 或者     -> "(T ? 4 : 5)"
          -> "4"                                    -> "4"
 

示例 3：

输入： "T?T?F:5:3"

输出： "F"

解释： 条件表达式自右向左结合。使用括号的话，相当于：

             "(T ? (T ? F : 5) : 3)"                   "(T ? (T ? F : 5) : 3)"
          -> "(T ? F : 3)"                 或者       -> "(T ? F : 5)"
          -> "F"                                     -> "F"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ternary-expression-parser
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第一种思路：

本题是典型的可用递归解题的问题，特点在于一个大问题需要拆分成类型完全相同，只是问题规模不同的小问题。

比如一个大问题 T:T:3?4:F， 处理完最外层的T之后，下一个小问题 T:3?4完全可以用相同的方法处理，因此可以用递归。

因此，只要找到expression中对应下一层小问题T的部分， 和对应下一层小问题F的部分，然后递归即可。

从左向右扫描，当？的个数 == ：的个数的时候，右边剩下的部分属于F，从第一个？的位置到此处的部分属于T。

class Solution(object):
    def parseTernary(self, expression):
        """
        :type expression: str
        :rtype: str
        """
        if not expression:
            return None
        if len(expression) == 1:
            return expression[0]
        question, colon = 0, 0
        pos1, pos2 = -1, -1
        for i, char in enumerate(expression):
            if char == "?":
                question += 1
                if question  == 1:
                    pos1 = i
            elif char == ":":
                colon += 1
                if colon == question:
                    pos2 = i
                    break
                    
        left_result = self.parseTernary(expression[pos1 + 1:pos2])
        right_result = self.parseTernary(expression[pos2 + 1:])
        
        return left_result if expression[0] =="T" else right_result

第二种思路：

用栈也是可以的。

 class Solution(object):
    def parseTernary(self, expression):
        """
        :type expression: str
        :rtype: str
        """
        stk = list(expression)
        k = list()
        while stk:
            c = stk.pop() #优先级从右往左，所以从最后往前算
            if c == '?': #遇到❓，就判断？之前的表达式是T还是F（现在栈=[..., F的结果， T的结果]）
                if stk.pop() == 'F':#如果是F，那么把T对应答案扔掉不要
                    k.pop()
                else:#如果是T，那么把F对应答案扔掉不要
                    a = k.pop() #先备份T的结果
                    k.pop()     #扔掉F的结果
                    k.append(a) #把T的结果再弄回来
            elif c != ":":
                k.append(c)

        return k[0]