Simple Virtual Machine - Problem

Build a stack-based virtual machine that executes bytecode instructions. Your VM should support the following operations:

Stack Operations:

PUSH value - Push a value onto the stack
POP - Pop and return the top value from stack

Arithmetic Operations:

ADD - Pop two values, push their sum
SUB - Pop two values, push difference (second - first)
MUL - Pop two values, push their product

Control Flow:

JMP address - Jump to instruction at given address
JEQ address - Jump if top two stack values are equal
HALT - Stop execution

Given an array of bytecode instructions, execute them and return the final stack state. Instructions are executed sequentially unless a jump occurs.

Input & Output

Example 1 — Basic Arithmetic

$ Input: instructions = ["PUSH 10", "PUSH 5", "ADD", "HALT"]

› Output: [15]

💡 Note: Push 10 and 5 onto stack: [10, 5]. ADD pops both, pushes sum 15: [15]. HALT stops execution.

Example 2 — Multiple Operations

$ Input: instructions = ["PUSH 3", "PUSH 4", "MUL", "PUSH 2", "SUB"]

› Output: [10]

💡 Note: Push 3, 4: [3, 4]. MUL gives [12]. Push 2: [12, 2]. SUB gives [10] (12-2=10).

Example 3 — Jump Operations

$ Input: instructions = ["PUSH 5", "PUSH 5", "JEQ 5", "PUSH 99", "HALT", "PUSH 100"]

› Output: [100]

💡 Note: Push 5, 5: [5, 5]. JEQ compares top values (equal), jumps to instruction 5. Executes PUSH 100: [100].

Constraints

1 ≤ instructions.length ≤ 1000
Each instruction is a valid bytecode operation
Jump addresses are within valid range [0, instructions.length)
Stack operations are performed only when sufficient elements exist

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 24 f Meta 18

Build a stack-based virtual machine by maintaining a stack and program counter. The key insight is treating each instruction as a command that manipulates stack state or controls execution flow. Best approach uses structured parsing with dispatch table for clean, extensible code. Time: O(n), Space: O(n).

Common Approaches

✓ Direct String Parsing

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

Read each instruction as a string, split it into parts, and execute immediately. Use simple string parsing to extract operation and arguments, maintaining a stack and program counter.

Function Dispatch Table

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

Pre-populate a hash map with function pointers or lambdas for each operation. This eliminates the need for long if-else chains or switch statements during execution, providing constant-time operation lookup.

Structured Instruction Processing

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

Parse all instructions into structured objects first, then execute using a cleaner dispatch mechanism. This separates parsing from execution and allows for better error handling and optimization.

Direct String Parsing — Algorithm Steps

Initialize empty stack and program counter at 0
For each instruction, split by space to get operation and arguments
Execute operation: PUSH adds to stack, POP removes, arithmetic operations combine values
Handle jumps by updating program counter, continue until HALT or end

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Instruction

Split instruction string into operation and arguments

Execute Operation

Perform stack manipulation or control flow

Update State

Move to next instruction or jump target

Code -

solution.c — C

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

int* solution(char instructions[][50], int instrCount, int* resultSize) {
    int* stack = malloc(1000 * sizeof(int));
    int stackSize = 0;
    int pc = 0;
    
    while (pc < instrCount) {
        char op[10];
        int val;
        
        if (sscanf(instructions[pc], "%s %d", op, &val) >= 1) {
            if (strcmp(op, "PUSH") == 0) {
                stack[stackSize++] = val;
            } else if (strcmp(op, "POP") == 0) {
                if (stackSize > 0) {
                    stackSize--;
                }
            } else if (strcmp(op, "ADD") == 0) {
                if (stackSize >= 2) {
                    int b = stack[--stackSize];
                    int a = stack[--stackSize];
                    stack[stackSize++] = a + b;
                }
            } else if (strcmp(op, "SUB") == 0) {
                if (stackSize >= 2) {
                    int b = stack[--stackSize];
                    int a = stack[--stackSize];
                    stack[stackSize++] = a - b;
                }
            } else if (strcmp(op, "MUL") == 0) {
                if (stackSize >= 2) {
                    int b = stack[--stackSize];
                    int a = stack[--stackSize];
                    stack[stackSize++] = a * b;
                }
            } else if (strcmp(op, "JMP") == 0) {
                pc = val;
                continue;
            } else if (strcmp(op, "JEQ") == 0) {
                if (stackSize >= 2) {
                    int b = stack[--stackSize];
                    int a = stack[--stackSize];
                    if (a == b) {
                        pc = val;
                        continue;
                    }
                    stack[stackSize++] = a;
                    stack[stackSize++] = b;
                }
            } else if (strcmp(op, "HALT") == 0) {
                break;
            }
        }
        
        pc++;
    }
    
    *resultSize = stackSize;
    return stack;
}

int main() {
    char instructions[100][50];
    int instrCount = 0;
    char line[1000];
    
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing - extract strings from JSON array
    char* token = strtok(line, "[\",]");
    while (token != NULL && instrCount < 100) {
        if (strlen(token) > 1) {
            strcpy(instructions[instrCount++], token);
        }
        token = strtok(NULL, "[\",]");
    }
    
    int resultSize;
    int* result = solution(instructions, instrCount, &resultSize);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each instruction may require string parsing, and jumps can cause instructions to be visited multiple times

✓ Linear Growth

Space Complexity

O(n)

Stack can grow up to n elements, plus string parsing overhead

⚡ Linearithmic Space

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

Simple Virtual Machine - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct String Parsing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler