Parsing A Boolean Expression - Practice Coding Problems

Parsing A Boolean Expression - Problem

Parse and Evaluate Boolean Expressions

You're tasked with building a boolean expression evaluator that can process nested logical operations. Think of it as creating a mini-interpreter for boolean logic!

The expression language supports:
• 't' - evaluates to true
• 'f' - evaluates to false
• '!(expr)' - logical NOT of the inner expression
• '&(expr1,expr2,...)' - logical AND of all inner expressions
• '|(expr1,expr2,...)' - logical OR of all inner expressions

Goal: Parse the given string expression and return its boolean evaluation result.

Example: "&(|(f))" → First evaluate |(f) which is false, then evaluate &(false) which is also false.

Input & Output

example_1.py — Simple AND operation

$ Input: expression = "&(|(f))"

› Output: false

💡 Note: First evaluate the inner OR operation: |(f) = false (OR of just false is false). Then evaluate the outer AND: &(false) = false (AND of just false is false).

example_2.py — OR with multiple values

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

› Output: true

💡 Note: OR operation with four values: f,f,f,t. Since at least one value is true, the result is true.

example_3.py — Nested NOT operation

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

› Output: true

💡 Note: First evaluate inner AND: &(f,t) = false (both values must be true for AND). Then apply NOT: !(false) = true.

Constraints

1 ≤ expression.length ≤ 2 × 10⁴
expression[i] is one following characters: '(', ')', '&', '|', '!', 't', 'f', and ','
The given string expression represents a valid boolean expression
All sub-expressions are guaranteed to be properly formatted

Visualization

Tap to expand

Understanding the Visualization

Read Expression

Start from left, identify if we see a boolean value or an operator

Handle Nesting

When we see an operator, parse everything inside its parentheses

Recursive Evaluation

For nested expressions, recursively evaluate inner parts first

Apply Logic

Use AND/OR/NOT operations on the boolean results

Key Takeaway

🎯 Key Insight: Use recursion with index tracking to naturally handle nested expressions - each recursive call processes one level of the expression tree, making the solution both elegant and efficient.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a recursive descent parser approach. By maintaining a global index and recursively parsing sub-expressions, we can evaluate the boolean expression in O(n) time with O(d) space where d is the maximum nesting depth. This approach naturally handles the nested structure of boolean expressions and processes each character exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Descent Parser (Stack-based)	O(n)	O(d)	Use recursion with index tracking to parse and evaluate expressions

Recursive Descent Parser (Stack-based) — Algorithm Steps

Start parsing from index 0 with recursive function
If current char is 't' or 'f', return boolean and advance index
If current char is operator, parse the full expression with parentheses
Recursively parse each sub-expression within the parentheses
Apply the operator to all sub-expression results

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Parse

Begin parsing from index 0

Identify Token

Check if current character is 't', 'f', or operator

Recursive Calls

For operators, recursively parse sub-expressions

Apply Operation

Combine results using the operator logic

Code -

solution.c — C

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

static int index_global;

bool parse(const char* expression) {
    char ch = expression[index_global++];
    
    if (ch == 't') {
        return true;
    } else if (ch == 'f') {
        return false;
    } else {
        char operator = ch;
        index_global++; // skip '('
        
        bool results[1000];
        int count = 0;
        
        while (expression[index_global] != ')') {
            if (expression[index_global] == ',') {
                index_global++; // skip comma
            } else {
                results[count++] = parse(expression);
            }
        }
        
        index_global++; // skip ')'
        
        // Apply operator
        if (operator == '!') {
            return !results[0];
        } else if (operator == '&') {
            for (int i = 0; i < count; i++) {
                if (!results[i]) return false;
            }
            return true;
        } else { // operator == '|'
            for (int i = 0; i < count; i++) {
                if (results[i]) return true;
            }
            return false;
        }
    }
}

bool parseBoolExpr(char* expression) {
    index_global = 0;
    return parse(expression);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is processed exactly once during parsing

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth proportional to expression nesting depth

✓ Linear Space

72.0K Views

Medium-High Frequency

~18 min Avg. Time

2.8K 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 Parser (Stack-based) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler