Ternary Expression Parser - Practice Coding Problems

Ternary Expression Parser - Problem

Ternary Expression Parser is a fascinating string parsing problem that simulates how programming languages evaluate conditional expressions.

Given a string containing nested ternary expressions (like "T?2:F?1:0"), you need to evaluate it and return the final result. The string contains:
• T and F for boolean values (true/false)
• ? and : for ternary operators
• Single digits (0-9) as values

The ternary operator works as: condition ? valueIfTrue : valueIfFalse

Just like in most programming languages, these expressions are right-associative, meaning they evaluate from right to left. For example, "T?T?F:5:3" is grouped as "T?(T?F:5):3".

Goal: Parse and evaluate the nested ternary expression to return a single character result.

Input & Output

example_1.py — Simple Ternary

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

› Output: "2"

💡 Note: Since the condition 'T' is true, we return the true value '2' instead of the false value '3'.

example_2.py — Nested Ternary

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

› Output: "4"

💡 Note: The condition 'F' is false, so we evaluate the false branch 'T?4:5'. Since 'T' is true, we return '4'.

example_3.py — Complex Nested

$ Input: expression = "T?T?F:5:3"

› Output: "F"

💡 Note: The condition 'T' is true, so we evaluate 'T?F:5'. Since the nested condition 'T' is true, we return 'F'.

Constraints

5 ≤ expression.length ≤ 10⁴
expression consists of digits, 'T', 'F', '?', and ':'
It is guaranteed that expression is a valid ternary expression
All numbers are single digits (0-9)

Visualization

Tap to expand

Understanding the Visualization

Start from Right

Begin processing from the rightmost character, pushing values onto stack

Encounter Question

When we see '?', we know the next two stack items are our choices

Make Decision

Look at the condition and pick the appropriate value

Continue

Push result back and continue until one value remains

Key Takeaway

🎯 Key Insight: By processing right-to-left with a stack, we naturally handle the right-associative nature of ternary expressions and evaluate them in the correct order.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a stack-based approach processing the expression from right to left. When encountering a '?', we pop two values from the stack (false and true values) and push back the result based on the condition. This achieves O(n) time complexity with a single pass through the string.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Descent Parsing	O(n)	O(n)	Parse the expression recursively by identifying condition, true, and false parts
Recursive Parsing (Brute Force)	O(n²)	O(n)	Recursively find and evaluate the rightmost ternary expression repeatedly
Stack-Based Parsing (Optimal)	O(n)	O(n)	Use a stack to process the expression from right to left in a single pass

Recursive Descent Parsing — Algorithm Steps

If the expression is a single character, return it
Otherwise, extract the condition (first character)
Find the matching colon for the first question mark
Split into true part (between ? and :) and false part (after :)
Recursively evaluate both parts
Return the appropriate result based on the condition

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Call

Start with full expression

Split Expression

Find condition, true part, and false part

Recursive Calls

Recursively evaluate the chosen branch

Return Result

Bubble up the final result

Code -

solution.c — C

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

char* parse(char* expr, char* result) {
    int len = strlen(expr);
    
    // Base case: single character
    if (len == 1) {
        result[0] = expr[0];
        result[1] = '\0';
        return result;
    }
    
    // Extract condition
    char condition = expr[0];
    
    // Find the matching colon for the first question mark
    int questionCount = 0;
    int colonPos = -1;
    
    for (int i = 2; i < len; i++) {
        if (expr[i] == '?') {
            questionCount++;
        } else if (expr[i] == ':') {
            if (questionCount == 0) {
                colonPos = i;
                break;
            }
            questionCount--;
        }
    }
    
    // Create true and false parts
    char truePart[1000], falsePart[1000];
    strncpy(truePart, expr + 2, colonPos - 2);
    truePart[colonPos - 2] = '\0';
    strcpy(falsePart, expr + colonPos + 1);
    
    // Recursively evaluate
    if (condition == 'T') {
        return parse(truePart, result);
    } else {
        return parse(falsePart, result);
    }
}

char* parseTernary(char* expression) {
    static char result[2];
    return parse(expression, result);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is processed once across all recursive calls

✓ Linear Growth

Space Complexity

O(n)

Recursion depth proportional to nesting level, plus substring creation

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Recursive Descent Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler