Lambda Calculus Evaluator - Problem

Implement a lambda calculus evaluator that can parse and evaluate lambda expressions with variable binding, function application, and beta reduction.

Lambda calculus is a formal system for expressing computation based on function abstraction and application. Your evaluator should handle:

Variables: x, y, z, etc.
Lambda abstractions: \x.body (function definition)
Function applications: (f x) (applying function f to argument x)
Beta reduction: (\x.body arg) → body[x := arg]

The input expression will be a valid lambda calculus expression as a string. Return the fully reduced expression as a string.

Input & Output

Example 1 — Simple Application

$ Input: (\x.x y)

› Output: y

💡 Note: Apply identity function \x.x to y: substitute x with y in body x, result is y

Example 2 — Nested Lambda

$ Input: (\x.\y.x y z)

› Output: z

💡 Note: Apply \x.\y.x to y and z: first substitute x with y getting \y.y, then apply to z getting z

Example 3 — No Reduction

$ Input: \x.x

› Output: \x.x

💡 Note: Identity function with no application, no beta reduction possible

Constraints

1 ≤ expression.length ≤ 1000
Expression contains only valid lambda calculus syntax
Variables are single lowercase letters
Expressions are well-formed and parenthesized correctly

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Apple 8 F Facebook 6

The key insight is building an Abstract Syntax Tree and using environment stacks for variable binding instead of naive string substitution. Best approach uses AST parsing with environment tracking for clean beta reduction. Time: O(n²), Space: O(n)

Common Approaches

✓ AST with Environment Stack

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

Build an Abstract Syntax Tree representation, then evaluate using an environment stack to track variable bindings and scope, avoiding repeated string parsing.

Brute Force Recursive Parsing

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

Parse the lambda expression into tokens, then recursively evaluate by repeatedly scanning for beta reductions and performing string substitutions until no more reductions are possible.

AST with Environment Stack — Algorithm Steps

Parse input into AST nodes (Variable, Lambda, Application)
Create environment stack for variable bindings
Recursively evaluate AST nodes with current environment
Handle beta reduction by extending environment
Convert final AST back to string representation

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse to AST

Build Abstract Syntax Tree

Environment

Track variable bindings in stack

Beta Reduce

Apply function by substituting in AST

Result

Convert AST back to string

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_TOKENS 200

typedef enum { VAR_TYPE, LAMBDA_TYPE, APP_TYPE } ExprType;

typedef struct Expr {
    ExprType type;
    union {
        struct { char name[50]; } var;
        struct { char param[50]; struct Expr* body; } lambda;
        struct { struct Expr* func; struct Expr* arg; } app;
    };
} Expr;

typedef struct {
    char tokens[MAX_TOKENS][50];
    int count;
} TokenList;

TokenList tokenize(const char* expr) {
    TokenList result;
    result.count = 0;
    int i = 0, len = strlen(expr);
    
    while (i < len && result.count < MAX_TOKENS - 1) {
        if (isspace(expr[i])) {
            i++;
        } else if (expr[i] == '\\') {
            strcpy(result.tokens[result.count++], "\\");
            i++;
        } else if (strchr("().", expr[i])) {
            result.tokens[result.count][0] = expr[i];
            result.tokens[result.count][1] = '\0';
            result.count++;
            i++;
        } else if (isalpha(expr[i])) {
            int j = 0;
            while (i < len && isalnum(expr[i]) && j < 49) {
                result.tokens[result.count][j++] = expr[i++];
            }
            result.tokens[result.count][j] = '\0';
            result.count++;
        } else {
            i++;
        }
    }
    return result;
}

Expr* createVar(const char* name) {
    Expr* expr = malloc(sizeof(Expr));
    expr->type = VAR_TYPE;
    strcpy(expr->var.name, name);
    return expr;
}

Expr* createLambda(const char* param, Expr* body) {
    Expr* expr = malloc(sizeof(Expr));
    expr->type = LAMBDA_TYPE;
    strcpy(expr->lambda.param, param);
    expr->lambda.body = body;
    return expr;
}

Expr* createApp(Expr* func, Expr* arg) {
    Expr* expr = malloc(sizeof(Expr));
    expr->type = APP_TYPE;
    expr->app.func = func;
    expr->app.arg = arg;
    return expr;
}

int pos;

Expr* parseExpr(TokenList* tokens) {
    if (pos >= tokens->count) return NULL;
    
    char* token = tokens->tokens[pos];
    
    if (strcmp(token, "\\") == 0) {
        pos++;
        if (pos >= tokens->count) return NULL;
        char* param = tokens->tokens[pos];
        pos++;
        if (pos >= tokens->count || strcmp(tokens->tokens[pos], ".") != 0) return NULL;
        pos++;
        Expr* body = parseExpr(tokens);
        return createLambda(param, body);
    } else if (strcmp(token, "(") == 0) {
        pos++;
        Expr* func = parseExpr(tokens);
        Expr* arg = parseExpr(tokens);
        if (pos < tokens->count && strcmp(tokens->tokens[pos], ")") == 0) {
            pos++;
        }
        return createApp(func, arg);
    } else if (isalpha(token[0])) {
        pos++;
        return createVar(token);
    } else {
        pos++;
        return parseExpr(tokens);
    }
}

void exprToString(Expr* expr, char* result) {
    if (!expr) {
        strcpy(result, "");
        return;
    }
    
    switch (expr->type) {
        case VAR_TYPE:
            strcpy(result, expr->var.name);
            break;
        case LAMBDA_TYPE: {
            char body[MAX_LEN];
            exprToString(expr->lambda.body, body);
            sprintf(result, "\\%s.%s", expr->lambda.param, body);
            break;
        }
        case APP_TYPE: {
            char func[MAX_LEN], arg[MAX_LEN];
            exprToString(expr->app.func, func);
            exprToString(expr->app.arg, arg);
            sprintf(result, "(%s %s)", func, arg);
            break;
        }
    }
}

char* solution(const char* expression) {
    static char result[MAX_LEN];
    TokenList tokens = tokenize(expression);
    pos = 0;
    Expr* ast = parseExpr(&tokens);
    
    if (!ast) {
        strcpy(result, expression);
        return result;
    }
    
    exprToString(ast, result);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single parsing phase O(n), evaluation may require O(n) reductions each taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

AST nodes and environment stack, single representation in memory

⚠ Quadratic Space

8.9K Views

Low Frequency

~45 min Avg. Time

245 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

Lambda Calculus Evaluator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

AST with Environment Stack — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler