lintcode练习- 887. 三元式解析器

描述

给定一个表示任意嵌套三元表达式的字符串expressions，计算表达式的结果。你可以假设给定的表达式是有效的，并且只由数字0-9,?，T和F组成 (T和F分别表示True和False)。

给定字符串的长度是≤10000。
每个整数都是个位数。
条件表达式组从右到左(跟大多数的语言一样)。
条件永远是T或F，条件永远不会是一个数字。
表达式的结果总是对一个数字0-9,T或F求值。

您在真实的面试中是否遇到过这个题？  是

样例

给定 expression = "T?2:3", 返回 "2".

解释：
如果为真，则结果为2;否则结果是3。

给定 expression = "F?1:T?4:5", 返回 "4".

解释：
条件表达式组从右到左，使用括号，它被读取/解析为:

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

给定 expression = "T?T?F:5:3", 返回 "F".

解释：
条件表达式组从右到左，使用括号，它被读取/解析为:

             "(T ? (T ? F : 5) : 3)"                   "(T ? (T ? F : 5) : 3)"
          -> "(T ? F : 3)"                 or       -> "(T ? F : 5)"
          -> "F"                                    -> "F"

实现代码：

    def parseTernary(self, expression):
        # write your code here
        stack = []
        pt = [0] * 10000
        if len(expression) == 0:
            return
        for i in range(len(expression)):
            if expression[i] == '?':
                stack.append(i)
            elif expression[i] == ':':
                #? and : 的对应关系
                nt = stack.pop()
                pt[i] = nt
                pt[nt] = i
            
        return self.dfs(pt, expression, 0, len(expression)-1)
    
    def dfs(self, pt, expression, st, ed):
        if st == ed:
            return expression[st]
        
        for i in range(st, ed):
            if expression[i] is '?':
                break
        #此时i 代表了 ？的坐标位置
        flag = expression[st]
        #ct 是 ？对应：的位置
        ct = pt[i]
        if flag == 'T':
            return self.dfs(pt, expression, i+1, ct-1)
        else:
            return self.dfs(pt, expression, ct+1, ed)