Parsing A Boolean Expression

Parsing A Boolean Expression - Problem

A boolean expression is an expression that evaluates to either true or false. It can be in one of the following shapes:

't' that evaluates to true
'f' that evaluates to false
'!(subExpr)' that evaluates to the logical NOT of the inner expression subExpr
'&(subExpr₁, subExpr₂, ..., subExprₙ)' that evaluates to the logical AND of the inner expressions subExpr₁, subExpr₂, ..., subExprₙ where n ≥ 1
'|(subExpr₁, subExpr₂, ..., subExprₙ)' that evaluates to the logical OR of the inner expressions subExpr₁, subExpr₂, ..., subExprₙ where n ≥ 1

Given a string expression that represents a boolean expression, return the evaluation of that expression.

It is guaranteed that the given expression is valid and follows the given rules.

Input & Output

Example 1 — OR Expression

$ Input: expression = "|(f,t)"

› Output: true

💡 Note: OR operation with operands false and true: f | t = true

Example 2 — Nested AND with OR and NOT

$ Input: expression = "&(|(t,f,t),!(t))"

› Output: false

💡 Note: First evaluate inner expressions: |(t,f,t) = true, !(t) = false. Then: &(true,false) = false

Example 3 — Complex Nesting

$ Input: expression = "|(!(f),&(t,t,t))"

› Output: true

💡 Note: Inner expressions: !(f) = true, &(t,t,t) = true. Then: |(true,true) = true

Constraints

1 ≤ expression.length ≤ 2 * 10⁴
expression[i] is one of 't', 'f', '!', '&', '|', '(', ')', and ','
expression is a valid boolean expression

Visualization

Tap to expand

Asked in

f Facebook 12 G Google 8 a Amazon 6 M Microsoft 4

The key insight is to parse boolean expressions using proper nesting handling. The stack-based approach is most efficient, processing each character once and using the stack to manage nested operations naturally. Time: O(n), Space: O(n)

Common Approaches

✓ Character-by-Character Parsing

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

Iterate through the string character by character, manually tracking parentheses depth and building sub-expressions. This approach requires complex state management to handle nested operations correctly.

Recursive with Memoization

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

Use recursion to naturally handle nesting by parsing from the outermost expression inward. Add memoization to cache results of repeated sub-expressions, though this is rarely needed for this problem since expressions are typically unique.

Stack-Based Parsing

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

Process the expression from left to right using a stack to keep track of operators and operands. When we encounter a closing parenthesis, we pop from the stack to evaluate the current operation.

Character-by-Character Parsing — Algorithm Steps

Scan character by character
Track parentheses nesting manually
Build and evaluate sub-expressions at each level

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Characters

Process each character while tracking depth

Extract Sub-expressions

Manually separate sub-expressions at depth 0

Recursive Evaluation

Evaluate each sub-expression recursively

Code -

solution.c — C

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

bool evaluate(char* expr) {
    if (strcmp(expr, "t") == 0) return true;
    if (strcmp(expr, "f") == 0) return false;
    
    char op = expr[0];
    int len = strlen(expr);
    char* content = malloc(len);
    strncpy(content, expr + 2, len - 3);
    content[len - 3] = '\0';
    
    char subExprs[100][1000];
    int subCount = 0;
    
    int i = 0, start = 0, depth = 0;
    int contentLen = strlen(content);
    
    while (i < contentLen) {
        char c = content[i];
        if (c == '(') {
            depth++;
        } else if (c == ')') {
            depth--;
        } else if (c == ',' && depth == 0) {
            strncpy(subExprs[subCount], content + start, i - start);
            subExprs[subCount][i - start] = '\0';
            subCount++;
            start = i + 1;
        }
        i++;
    }
    
    if (start < contentLen) {
        strcpy(subExprs[subCount], content + start);
        subCount++;
    }
    
    bool result = false;
    if (op == '!') {
        result = !evaluate(subExprs[0]);
    } else if (op == '&') {
        result = true;
        for (int j = 0; j < subCount; j++) {
            if (!evaluate(subExprs[j])) {
                result = false;
                break;
            }
        }
    } else if (op == '|') {
        result = false;
        for (int j = 0; j < subCount; j++) {
            if (evaluate(subExprs[j])) {
                result = true;
                break;
            }
        }
    }
    
    free(content);
    return result;
}

bool solution(char* expression) {
    return evaluate(expression);
}

int main() {
    char expression[20000];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    bool result = solution(expression);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple passes needed to resolve nested expressions, potentially O(n) passes for O(n) characters

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store intermediate sub-expression strings during processing

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Character-by-Character Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler