Parse Lisp Expression - Practice Coding Problems

Parse Lisp Expression - Problem

Imagine you're building an interpreter for a simplified Lisp programming language! Your task is to parse and evaluate mathematical expressions written in a special syntax.

You'll encounter four types of expressions:

Integers: Simple numbers like 42 or -15
Variables: Named values like x or count1
Add expressions: (add 3 5) evaluates to 8
Mult expressions: (mult 4 6) evaluates to 24
Let expressions: (let x 2 y 3 (add x y)) assigns x=2, y=3, then evaluates (add x y) to get 5

The tricky part? Variable scoping! When variables are redefined in nested expressions, the innermost definition takes precedence, just like in real programming languages.

Example: (let x 1 (let x 2 x)) returns 2 because the inner x shadows the outer one.

Input & Output

example_1.py — Simple Addition

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

› Output: 3

💡 Note: Basic addition operation: 1 + 2 = 3. The add operator takes two operands and returns their sum.

example_2.py — Let Expression with Variable

$ Input: expression = "(let x 2 (mult x 5))"

› Output: 10

💡 Note: First assigns x = 2, then evaluates (mult x 5) = (mult 2 5) = 10. The let expression creates a local scope where x has value 2.

example_3.py — Nested Scopes with Variable Shadowing

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

› Output: 2

💡 Note: The outer let assigns x = 1, but the inner let reassigns x = 2. The final expression 'x' refers to the inner scope's value of 2, demonstrating variable shadowing.

Constraints

1 ≤ expression.length ≤ 2000
The given expression is guaranteed to be a legal Lisp expression
The final answer will fit in a 32-bit integer
Variable names consist of lowercase letters and digits only
Protected keywords: "add", "let", "mult" will never be used as variable names

Visualization

Tap to expand

Understanding the Visualization

Tokenize the Expression

Break the expression string into meaningful tokens: parentheses, operators, variables, and numbers

Create Scope Hierarchy

Each opening parenthesis creates a new scope box that can inherit variables from outer boxes

Process Let Assignments

For let expressions, assign variables to the current scope box, shadowing any outer variables with the same name

Evaluate Operations

For add/mult operations, recursively evaluate operands using the current variable scope

Return and Clean Up

Return the computed value and automatically clean up the current scope as the recursion unwinds

Key Takeaway

🎯 Key Insight: Use a recursive approach where each function call manages its own variable scope through hash maps. This naturally handles the nested scoping rules of Lisp while maintaining O(n) time complexity through efficient tokenization and O(1) variable lookups.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses recursive parsing with scope management through a stack of hash maps. Each recursive call manages its own variable scope, inheriting from parent scopes. The key insight is using tokenization to parse expressions efficiently and scope stacking to handle variable shadowing naturally. Time complexity is O(n) where n is the expression length, and space complexity is O(d) where d is the maximum nesting depth.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Parsing with Global Variables)	O(n²)	O(n)	Parse expressions character by character with a single global variable map
Recursive Stack-based Parsing (Optimal)	O(n)	O(d)	Use recursion with scope stack to handle variable scoping efficiently

Brute Force (String Parsing with Global Variables) — Algorithm Steps

Parse the expression string character by character
For each let expression, backup current variable values
Assign new variables to the global map
Recursively evaluate the inner expression
Restore the previous variable state
Return the computed result

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Character by Character

Manually scan through the expression string to identify tokens

Backup Variables

For let expressions, save current variable state

Process Assignments

Update global variables with new assignments

Evaluate Expression

Recursively evaluate the inner expression

Restore State

Restore previous variable values after evaluation

Code -

solution.c — C

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

#define MAX_VARS 1000
#define MAX_LEN 100

typedef struct {
    char name[MAX_LEN];
    int value;
} Variable;

Variable variables[MAX_VARS];
int varCount = 0;

int findVariable(const char* name) {
    for (int i = varCount - 1; i >= 0; i--) {
        if (strcmp(variables[i].name, name) == 0) {
            return variables[i].value;
        }
    }
    return 0;
}

void addVariable(const char* name, int value) {
    strcpy(variables[varCount].name, name);
    variables[varCount].value = value;
    varCount++;
}

int parseExpression(char* expr) {
    // Trim whitespace
    while (*expr == ' ') expr++;
    int len = strlen(expr);
    while (len > 0 && expr[len-1] == ' ') expr[--len] = '\0';
    
    if (expr[0] != '(') {
        if (isdigit(expr[0]) || expr[0] == '-') {
            return atoi(expr);
        }
        return findVariable(expr);
    }
    
    // Simple tokenization for this example
    char* tokens[20];
    int tokenCount = 0;
    
    int i = 1; // Skip opening paren
    while (i < len - 1) {
        if (expr[i] == ' ') {
            i++;
            continue;
        }
        int start = i;
        if (expr[i] == '(') {
            int parenCount = 1;
            i++;
            while (parenCount > 0) {
                if (expr[i] == '(') parenCount++;
                else if (expr[i] == ')') parenCount--;
                i++;
            }
        } else {
            while (i < len - 1 && expr[i] != ' ' && expr[i] != ')') {
                i++;
            }
        }
        tokens[tokenCount] = malloc(i - start + 1);
        strncpy(tokens[tokenCount], expr + start, i - start);
        tokens[tokenCount][i - start] = '\0';
        tokenCount++;
    }
    
    char* op = tokens[0];
    int result = 0;
    
    if (strcmp(op, "add") == 0) {
        result = parseExpression(tokens[1]) + parseExpression(tokens[2]);
    } else if (strcmp(op, "mult") == 0) {
        result = parseExpression(tokens[1]) * parseExpression(tokens[2]);
    } else if (strcmp(op, "let") == 0) {
        int oldVarCount = varCount;
        for (int j = 1; j < tokenCount - 1; j += 2) {
            if (j + 1 < tokenCount - 1) {
                addVariable(tokens[j], parseExpression(tokens[j + 1]));
            }
        }
        result = parseExpression(tokens[tokenCount - 1]);
        varCount = oldVarCount; // Restore scope
    }
    
    // Free tokens
    for (int j = 0; j < tokenCount; j++) {
        free(tokens[j]);
    }
    
    return result;
}

int evaluate(char* expression) {
    varCount = 0;
    return parseExpression(expression);
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each variable lookup and assignment can take O(n) time in worst case with deep nesting

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and variable storage

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~35 min Avg. Time

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

Brute Force (String Parsing with Global Variables) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler