Parse Lisp Expression

Parse Lisp Expression - Problem

You are given a string expression representing a Lisp-like expression. Your task is to return the integer value after evaluating this expression.

Expression Types:

Integer: A positive or negative integer
Variable: A string starting with lowercase letter, followed by lowercase letters or digits
Let Expression: (let v1 e1 v2 e2 ... vn en expr) - assigns variables sequentially, then evaluates expr
Add Expression: (add e1 e2) - returns sum of two expressions
Mult Expression: (mult e1 e2) - returns product of two expressions

Scoping Rules: Variables are resolved from innermost to outermost scope. The names add, let, and mult are reserved and will never be used as variable names.

Input & Output

Example 1 — Let Expression

$ Input: expression = "(let x 2 (mult x (let x 3 y 4 (add x y))))"

› Output: 14

💡 Note: Outer scope: x=2. Inner scope: x=3, y=4. Inner expression: add(3,4)=7. Outer expression: mult(2,7)=14.

Example 2 — Nested Add

$ Input: expression = "(add 1 (mult 2 3))"

› Output: 7

💡 Note: First evaluate mult(2,3)=6, then add(1,6)=7.

Example 3 — Variable Scoping

$ Input: expression = "(let x 3 x 2 x)"

› Output: 2

💡 Note: Variable x is reassigned: first x=3, then x=2. Final expression evaluates x which is 2.

Constraints

1 ≤ expression.length ≤ 2000
The expression is syntactically correct
All integers are within the 32-bit signed integer range

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 a Amazon 6

The key insight is to use recursive parsing to naturally handle nested expressions and maintain variable scoping. The recursive approach with scope passing provides the cleanest solution. Time: O(n), Space: O(d) where d is nesting depth.

Common Approaches

✓ Recursive Parsing with Stack

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

Parse the expression recursively where each function call handles one expression level. Use the implicit call stack to manage nesting and maintain variable scopes through parameter passing.

String Parsing with Stack

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

Manually parse the string character by character, using a stack to track nested expressions and maintain variable scopes. This approach handles each token individually without leveraging recursive structure.

Recursive Parsing with Stack — Algorithm Steps

Parse expression recursively
Use call stack for nesting
Pass variable scopes as parameters
Handle each expression type in separate recursive calls

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Start

Begin parsing at outermost expression

Recursive Calls

Each nested expression creates new recursive call

Scope Chain

Variable scopes passed down through recursion

Code -

solution.c — C

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

char expr[2001];
int index_pos;

typedef struct Var {
    char name[64];
    int value;
    struct Var* next;
} Var;

Var* copyScope(Var* scope) {
    if (!scope) return NULL;
    Var* newVar = (Var*)malloc(sizeof(Var));
    strcpy(newVar->name, scope->name);
    newVar->value = scope->value;
    newVar->next = copyScope(scope->next);
    return newVar;
}

void freeScope(Var* scope) {
    while (scope) {
        Var* next = scope->next;
        free(scope);
        scope = next;
    }
}

int lookupScope(Var* scope, const char* name, int* found) {
    while (scope) {
        if (strcmp(scope->name, name) == 0) {
            *found = 1;
            return scope->value;
        }
        scope = scope->next;
    }
    *found = 0;
    return 0;
}

Var* setScope(Var* scope, const char* name, int value) {
    Var* cur = scope;
    while (cur) {
        if (strcmp(cur->name, name) == 0) {
            cur->value = value;
            return scope;
        }
        cur = cur->next;
    }
    Var* newVar = (Var*)malloc(sizeof(Var));
    strcpy(newVar->name, name);
    newVar->value = value;
    newVar->next = scope;
    return newVar;
}

void skipSpaces() {
    while (expr[index_pos] == ' ') index_pos++;
}

void parseToken(char* buf) {
    skipSpaces();
    int start = index_pos;
    while (expr[index_pos] && expr[index_pos] != '(' && expr[index_pos] != ')' && expr[index_pos] != ' ')
        index_pos++;
    int len = index_pos - start;
    strncpy(buf, expr + start, len);
    buf[len] = '\0';
}

int parse(Var* scope) {
    skipSpaces();

    if (expr[index_pos] == '(') {
        index_pos++;
        skipSpaces();
        char op[8];
        parseToken(op);

        if (strcmp(op, "let") == 0) {
            Var* newScope = copyScope(scope);
            while (1) {
                skipSpaces();
                if (expr[index_pos] == ')') {
                    index_pos++;
                    freeScope(newScope);
                    return 0;
                }

                if (expr[index_pos] == '(') {
                    int result = parse(newScope);
                    skipSpaces();
                    index_pos++;
                    freeScope(newScope);
                    return result;
                }

                char var[64];
                parseToken(var);
                skipSpaces();

                if (expr[index_pos] == ')') {
                    index_pos++;
                    int result;
                    if (var[0] == '-' || isdigit((unsigned char)var[0]))
                        result = atoi(var);
                    else {
                        int found;
                        result = lookupScope(newScope, var, &found);
                    }
                    freeScope(newScope);
                    return result;
                }

                int val = parse(newScope);
                newScope = setScope(newScope, var, val);
            }
        } else if (strcmp(op, "add") == 0) {
            int val1 = parse(scope);
            int val2 = parse(scope);
            skipSpaces();
            index_pos++;
            return val1 + val2;
        } else if (strcmp(op, "mult") == 0) {
            int val1 = parse(scope);
            int val2 = parse(scope);
            skipSpaces();
            index_pos++;
            return val1 * val2;
        }
    } else {
        char token[64];
        parseToken(token);
        if (token[0] == '-' || isdigit((unsigned char)token[0]))
            return atoi(token);
        int found;
        return lookupScope(scope, token, &found);
    }
    return 0;
}

int solution(const char* expression_input) {
    strcpy(expr, expression_input);
    index_pos = 0;
    return parse(NULL);
}

int main() {
    char line[2001];
    fgets(line, sizeof(line), stdin);
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') line[len-1] = '\0';
    printf("%d\n", solution(line));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character in expression processed once during recursive parsing

✓ Linear Growth

Space Complexity

O(d)

Recursion depth d for nested expressions plus variable scope storage

✓ Linear Space

18.4K Views

Medium Frequency

~35 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

Recursive Parsing with Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler