439. Ternary Expression Parser

package LeetCode_439

import java.util.*

/**
 * 439. Ternary Expression Parser
 * (Prime)
 * Given a string representing arbitrarily nested ternary expressions, calculate the result of the expression.
 * You can always assume that the given expression is valid and only consists of digits 0-9, ?, :,
 * T and F (T and F represent True and False respectively).
Note:
1. The length of the given string is ≤ 10000.
2. Each number will contain only one digit.
3. The conditional expressions group right-to-left (as usual in most languages).
4. The condition will always be either T or F. That is, the condition will never be a digit.
5. The result of the expression will always evaluate to either a digit 0-9, T or F.
Example 1:
Input: "T?2:3"
Output: "2"
Explanation: If true, then result is 2; otherwise result is 3.

Example 2:
Input: "F?1:T?4:5"
Output: "4"
Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:
"(F ? 1 : (T ? 4 : 5))"                   "(F ? 1 : (T ? 4 : 5))"
-> "(F ? 1 : 4)"                 or       -> "(T ? 4 : 5)"
-> "4"                                    -> "4"

Example 3:
Input: "T?T?F:5:3"
Output: "F"
Explanation: The conditional expressions group right-to-left. Using parenthesis, it is read/evaluated as:
"(T ? (T ? F : 5) : 3)"                   "(T ? (T ? F : 5) : 3)"
-> "(T ? F : 3)"                 or       -> "(T ? F : 5)"
-> "F"                                    -> "F"
 * */
class Solution {
    /*
    * solution: Stack, scan expression from right to left, if meet ?,remove : and check which one to keep in stack,
    * Time:O(n), Space:O(n)
    * */
    fun parseTernary(expression: String): String {
        val stack = Stack<Char>()
        for (i in expression.length - 1 downTo 0) {
            if (stack.isNotEmpty() && stack.peek() == '?') {
                /*
                * if peek in stack is ?, so current char is T or F,
                * for example" T?2:3, peek of stack is ?, current scanning char is T,
                * */
                stack.pop()//pop question mark
                val first = stack.pop()
                stack.pop()//pop :
                val second = stack.pop()
                //check which one need push back to stack
                stack.push(if (expression[i]=='T') first else second)
            } else {
                stack.push(expression[i])
            }
        }
        //the result remaining in stack
        return stack.peek().toString()
    }

}