Bytecode Compiler - Problem

Compiler Compiler VM Hard

Design and implement a bytecode compiler for a simple expression language that targets a stack-based virtual machine.

Your task: Given a mathematical expression as a string, compile it into a sequence of bytecode instructions that can be executed on a stack-based VM.

Supported Operations:

Numbers: integers (e.g., 42, -5)
Binary operators: +, -, *, /
Parentheses for grouping: (, )

Bytecode Instructions:

PUSH n - Push number n onto stack
ADD - Pop two values, push their sum
SUB - Pop two values, push (second - first)
MUL - Pop two values, push their product
DIV - Pop two values, push (second / first)

Example: Expression "3 + 4 * 2" should compile to ["PUSH 3", "PUSH 4", "PUSH 2", "MUL", "ADD"]

Note: Follow standard operator precedence (* and / before + and -) and left-to-right associativity.

Input & Output

Example 1 — Basic Expression with Precedence

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

› Output: ["PUSH 3", "PUSH 4", "PUSH 2", "MUL", "ADD"]

💡 Note: Multiplication has higher precedence, so 4 * 2 is computed first: PUSH 4, PUSH 2, MUL (stack now has [3, 8]), then ADD gives 11

Example 2 — Parentheses Override Precedence

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

› Output: ["PUSH 3", "PUSH 4", "ADD", "PUSH 2", "MUL"]

💡 Note: Parentheses force addition first: PUSH 3, PUSH 4, ADD (stack: [7]), PUSH 2, MUL gives 14

Example 3 — Simple Addition

$ Input: expression = "5 + 7"

› Output: ["PUSH 5", "PUSH 7", "ADD"]

💡 Note: Basic addition: push both operands, then ADD instruction pops them and pushes sum (12)

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8 A Apple 6

The key insight is using the Shunting Yard algorithm with operator precedence to convert infix expressions directly to postfix bytecode. The optimal approach uses two stacks (output and operators) to handle precedence rules in a single pass. Time: O(n), Space: O(n)

Common Approaches

✓ Recursive Descent Parser

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

Parse the expression into a tree structure using recursive descent, respecting operator precedence and associativity. Then traverse the tree in post-order to generate bytecode instructions.

Shunting Yard Algorithm

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

Parse expression left-to-right using two stacks: operand stack for numbers and operator stack for operations. Handle precedence by popping operators when encountering lower precedence.

Recursive Descent Parser — Algorithm Steps

Parse expression into abstract syntax tree
Handle operator precedence recursively
Traverse tree post-order to emit bytecode

Visualization

Tap to expand

Step-by-Step Walkthrough

Tokenize

Split '3 + 4 * 2' into tokens: [3, +, 4, *, 2]

Parse Tree

Build AST respecting precedence: + at root, * as right subtree

Generate

Post-order traversal emits: PUSH 3, PUSH 4, PUSH 2, MUL, ADD

Code -

solution.c — C

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

#define MAX_TOKENS 1000
#define MAX_BYTECODE 1000
#define MAX_TOKEN_LEN 20

typedef enum { NUMBER, OPERATOR } TokenType;

typedef struct {
    TokenType type;
    union {
        int number;
        char op;
    } value;
} Token;

typedef enum { NUM_NODE, BIN_OP_NODE } NodeType;

typedef struct ASTNode {
    NodeType type;
    union {
        int number;
        struct {
            struct ASTNode* left;
            char op;
            struct ASTNode* right;
        } binOp;
    } data;
} ASTNode;

typedef struct {
    ASTNode* node;
    int pos;
} ParseResult;

char** solution(char* expression, int* returnSize) {
    Token tokens[MAX_TOKENS];
    int tokenCount = tokenize(expression, tokens);
    ParseResult result = parseExpression(tokens, tokenCount, 0);
    char** bytecode = malloc(MAX_BYTECODE * sizeof(char*));
    *returnSize = 0;
    generateCode(result.node, bytecode, returnSize);
    return bytecode;
}

int tokenize(char* expr, Token* tokens) {
    int count = 0;
    int i = 0;
    int len = strlen(expr);
    
    while (i < len) {
        if (isspace(expr[i])) {
            i++;
        } else if (isdigit(expr[i]) || (expr[i] == '-' && i + 1 < len && isdigit(expr[i + 1]) && (i == 0 || strchr("(+-*/", expr[i-1])))) {
            int start = i;
            if (expr[i] == '-') i++;
            while (i < len && isdigit(expr[i])) i++;
            char numStr[20];
            strncpy(numStr, expr + start, i - start);
            numStr[i - start] = '\0';
            tokens[count].type = NUMBER;
            tokens[count].value.number = atoi(numStr);
            count++;
        } else {
            tokens[count].type = OPERATOR;
            tokens[count].value.op = expr[i];
            count++;
            i++;
        }
    }
    return count;
}

ASTNode* createNumberNode(int value) {
    ASTNode* node = malloc(sizeof(ASTNode));
    node->type = NUM_NODE;
    node->data.number = value;
    return node;
}

ASTNode* createBinaryOpNode(ASTNode* left, char op, ASTNode* right) {
    ASTNode* node = malloc(sizeof(ASTNode));
    node->type = BIN_OP_NODE;
    node->data.binOp.left = left;
    node->data.binOp.op = op;
    node->data.binOp.right = right;
    return node;
}

ParseResult parseExpression(Token* tokens, int tokenCount, int pos);
ParseResult parseTerm(Token* tokens, int tokenCount, int pos);
ParseResult parseFactor(Token* tokens, int tokenCount, int pos);

ParseResult parseExpression(Token* tokens, int tokenCount, int pos) {
    ParseResult left = parseTerm(tokens, tokenCount, pos);
    pos = left.pos;
    while (pos < tokenCount && tokens[pos].type == OPERATOR && (tokens[pos].value.op == '+' || tokens[pos].value.op == '-')) {
        char op = tokens[pos].value.op;
        pos++;
        ParseResult right = parseTerm(tokens, tokenCount, pos);
        pos = right.pos;
        left.node = createBinaryOpNode(left.node, op, right.node);
        left.pos = pos;
    }
    return left;
}

ParseResult parseTerm(Token* tokens, int tokenCount, int pos) {
    ParseResult left = parseFactor(tokens, tokenCount, pos);
    pos = left.pos;
    while (pos < tokenCount && tokens[pos].type == OPERATOR && (tokens[pos].value.op == '*' || tokens[pos].value.op == '/')) {
        char op = tokens[pos].value.op;
        pos++;
        ParseResult right = parseFactor(tokens, tokenCount, pos);
        pos = right.pos;
        left.node = createBinaryOpNode(left.node, op, right.node);
        left.pos = pos;
    }
    return left;
}

ParseResult parseFactor(Token* tokens, int tokenCount, int pos) {
    if (tokens[pos].type == NUMBER) {
        ParseResult result = {createNumberNode(tokens[pos].value.number), pos + 1};
        return result;
    } else if (tokens[pos].type == OPERATOR && tokens[pos].value.op == '(') {
        pos++;
        ParseResult expr = parseExpression(tokens, tokenCount, pos);
        ParseResult result = {expr.node, expr.pos + 1};
        return result;
    }
    ParseResult result = {NULL, pos};
    return result;
}

void generateCode(ASTNode* node, char** bytecode, int* count) {
    if (node->type == NUM_NODE) {
        bytecode[*count] = malloc(20);
        sprintf(bytecode[*count], "PUSH %d", node->data.number);
        (*count)++;
    } else if (node->type == BIN_OP_NODE) {
        generateCode(node->data.binOp.left, bytecode, count);
        generateCode(node->data.binOp.right, bytecode, count);
        bytecode[*count] = malloc(10);
        switch (node->data.binOp.op) {
            case '+': strcpy(bytecode[*count], "ADD"); break;
            case '-': strcpy(bytecode[*count], "SUB"); break;
            case '*': strcpy(bytecode[*count], "MUL"); break;
            case '/': strcpy(bytecode[*count], "DIV"); break;
        }
        (*count)++;
    }
}

int main() {
    char expression[1000];
    fgets(expression, sizeof(expression), stdin);
    expression[strcspn(expression, "\n")] = 0;
    
    int returnSize;
    char** result = solution(expression, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to build tree plus single traversal to emit code

✓ Linear Growth

Space Complexity

O(n)

Parse tree nodes and recursion stack for expression depth

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Bytecode Compiler - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive Descent Parser — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler