Recursive Descent Parser - Problem

Build a recursive descent parser for arithmetic expressions that correctly handles operator precedence and parentheses.

Your parser should parse expressions with:

Numbers: Non-negative integers (0-9 digits)
Operators: + (addition), - (subtraction), * (multiplication), / (integer division)
Parentheses: ( and ) for grouping

The parser should follow standard mathematical precedence:

Parentheses (highest priority)
Multiplication and Division (left-to-right)
Addition and Subtraction (left-to-right, lowest priority)

Return the evaluated result of the parsed expression as an integer.

Input & Output

Example 1 — Basic Precedence

$ Input: expression = "2+3*4"

› Output: 14

💡 Note: Multiplication has higher precedence: 3*4 = 12, then 2+12 = 14

Example 2 — Parentheses Override

$ Input: expression = "(2+3)*4"

› Output: 20

💡 Note: Parentheses first: (2+3) = 5, then 5*4 = 20

Example 3 — Division and Subtraction

$ Input: expression = "10-2*3/2"

› Output: 7

💡 Note: Left-to-right for same precedence: 2*3 = 6, 6/2 = 3, then 10-3 = 7

Constraints

1 ≤ expression.length ≤ 1000
expression contains only digits, +, -, *, /, (, ), and spaces
All intermediate results fit in 32-bit integer range
No division by zero

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 35 F Facebook 30 a Amazon 25

The key insight is using recursive descent parsing to naturally handle operator precedence through function call hierarchy. The recursive descent approach creates separate parsing functions for each precedence level, making the code clean and extensible. Time: O(n), Space: O(d) where d is nesting depth.

Common Approaches

✓ Character-by-Character State Machine

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

Iterate through each character, maintaining state for current number, operator, and result. Handle precedence by storing pending operations and resolving them based on priority rules.

Recursive Descent Parser

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

Implement separate functions for each grammar rule (expression, term, factor) that call each other recursively, naturally handling operator precedence through the call hierarchy.

Shunting Yard Algorithm

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

Use Dijkstra's Shunting Yard algorithm to convert infix expression to postfix (RPN), then evaluate the postfix expression using a stack. This separates parsing from evaluation.

Character-by-Character State Machine — Algorithm Steps

Scan character by character, building numbers digit by digit
For each operator, check precedence against previous operator
Manually handle parentheses by tracking nesting level
Resolve operations in correct order using explicit precedence checks

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up stack, current number, and operator

Parse

Process each character, handle precedence

Evaluate

Sum all values in stack for final result

Code -

solution.c — C

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

#define MAX_SIZE 1000

int evaluate(char* expr);

int solution(char* expression) {
    // Remove spaces
    char cleaned[MAX_SIZE];
    int j = 0;
    for (int i = 0; expression[i]; i++) {
        if (expression[i] != ' ') {
            cleaned[j++] = expression[i];
        }
    }
    cleaned[j] = '\0';
    return evaluate(cleaned);
}

int evaluate(char* expr) {
    int stack[MAX_SIZE];
    int top = -1;
    int num = 0;
    char op = '+';
    int len = strlen(expr);
    
    for (int i = 0; i <= len; i++) {
        char ch = i < len ? expr[i] : '+';
        
        if (isdigit(ch)) {
            num = num * 10 + (ch - '0');
        } else if (ch == '(') {
            int count = 1;
            int j = i + 1;
            while (count > 0) {
                if (expr[j] == '(') count++;
                else if (expr[j] == ')') count--;
                j++;
            }
            // Extract substring and evaluate recursively
            char sub[MAX_SIZE];
            int k;
            for (k = 0; k < j - i - 2; k++) {
                sub[k] = expr[i + 1 + k];
            }
            sub[k] = '\0';
            num = evaluate(sub);
            i = j - 1;
        }
        
        if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || i == len) {
            if (op == '+') {
                stack[++top] = num;
            } else if (op == '-') {
                stack[++top] = -num;
            } else if (op == '*') {
                stack[top] *= num;
            } else if (op == '/') {
                stack[top] /= num;
            }
            op = ch;
            num = 0;
        }
    }
    
    int result = 0;
    for (int i = 0; i <= top; i++) {
        result += stack[i];
    }
    return result;
}

int main() {
    char expression[MAX_SIZE];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    printf("%d\n", solution(expression));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each character may trigger precedence resolution that scans previous operators

✓ Linear Growth

Space Complexity

O(n)

Stack to store pending operations and operands

⚡ Linearithmic Space

24.0K Views

Medium Frequency

~35 min Avg. Time

890 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

Recursive Descent Parser - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character State Machine — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler