Ternary Expression Parser

Ternary Expression Parser - Problem

Given a string expression representing arbitrarily nested ternary expressions, evaluate the expression and return the result.

You can always assume that the given expression is valid and only contains digits '0'-'9', '?', ':', 'T' (true), and 'F' (false).

Note:

All numbers in the expression are one-digit numbers (i.e., in the range [0, 9])
The conditional expressions group right-to-left (as usual in most languages)
The result will always evaluate to either a digit, 'T', or 'F'

Input & Output

Example 1 — Simple Ternary

$ Input: expression = "T?2:3"

› Output: "2"

💡 Note: Condition is T (true), so we return the true value which is '2'

Example 2 — Nested Ternary

$ Input: expression = "F?1:T?4:5"

› Output: "4"

💡 Note: Condition is F (false), so we evaluate T?4:5. T is true, so return '4'

Example 3 — Complex Nesting

$ Input: expression = "T?T?F?1:2:3:4"

› Output: "2"

💡 Note: T is true, so evaluate T?F?1:2:3. T is true, so evaluate F?1:2. F is false, so return '2'

Constraints

5 ≤ expression.length ≤ 10⁴
expression consists of digits, 'T', 'F', '?', and ':'
It is guaranteed that expression is a valid ternary expression
Each number in the expression is a one-digit number

Visualization

Tap to expand

Asked in

f Facebook 8 G Google 5

The key insight is understanding that ternary expressions are right-associative. The optimal approach uses either a stack processing from right to left or recursive descent parsing. Both achieve O(n) time complexity by processing each character exactly once.

Common Approaches

✓ Iterative String Replacement

⏱️ Time: O(n²) Space: O(n)

Find the first complete ternary expression (condition?true_val:false_val) where both true_val and false_val are single characters, evaluate it, and replace it with the result. Repeat until the entire expression is evaluated.

Recursive Descent Parser

⏱️ Time: O(n) Space: O(d)

Implement a recursive descent parser that handles the right-associative nature of ternary operators. Parse from left to right, but handle the precedence by recursively parsing the false branch.

Stack-Based Evaluation

⏱️ Time: O(n) Space: O(n)

Process the expression from right to left using a stack. When we encounter a ':', we know we have a complete ternary expression and can evaluate it immediately.

Iterative String Replacement — Algorithm Steps

Step 1: Scan for simple ternary patterns
Step 2: Evaluate and replace with result
Step 3: Repeat until single character remains

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Pattern

Locate first simple ternary (char?char:char)

Evaluate

Replace pattern with result

Repeat

Continue until single character remains

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int isValue(char c) {
    return c == 'T' || c == 'F' || (c >= '0' && c <= '9');
}

char* solution(char* expression) {
    int len = strlen(expression);
    char* result = malloc(len + 1);
    strcpy(result, expression);
    
    while (strlen(result) > 1) {
        int found = 0;
        int currentLen = strlen(result);
        // Find the rightmost simple ternary expression
        for (int i = currentLen - 5; i >= 0; i--) {  // Start from rightmost possible position
            if (i + 4 < currentLen &&
                result[i+1] == '?' && result[i+3] == ':' &&
                isValue(result[i]) &&
                isValue(result[i+2]) &&
                isValue(result[i+4])) {
                // Evaluate the ternary
                char condition = result[i];
                char trueVal = result[i+2];
                char falseVal = result[i+4];
                char evalResult = condition != 'F' ? trueVal : falseVal;
                // Replace this part with the result
                result[i] = evalResult;
                memmove(result + i + 1, result + i + 5, currentLen - i - 4);
                found = 1;
                break;
            }
        }
        if (!found) break;
    }
    return result;
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    // Remove newline
    expression[strcspn(expression, "\n")] = 0;
    
    char* result = solution(expression);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each iteration processes the string and creates a new string, with up to n iterations

✓ Linear Growth

Space Complexity

O(n)

String operations create new strings of length up to n

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative String Replacement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler