Calculate Score After Performing Instructions

Calculate Score After Performing Instructions - Problem

Instruction Execution Simulator

Imagine you're implementing a simple virtual machine that processes a sequence of instructions! 🖥️

You are given two arrays: instructions and values, both of size n. Your task is to simulate an instruction pointer moving through these arrays while maintaining a score.

The Rules:
• Start at index i = 0 with score = 0
• If instructions[i] == "add": Add values[i] to your score and move to i + 1
• If instructions[i] == "jump": Move to index i + values[i] (no score change)

The simulation ends when:
• You go out of bounds (i < 0 or i >= n), OR
• You attempt to revisit a previously executed instruction

Return the final score when the simulation terminates.

Input & Output

example_1.py — Basic Simulation

$ Input: instructions = ["add", "jump", "add", "jump", "add"], values = [5, 2, 3, -2, 1]

› Output: 5

💡 Note: Start at i=0: execute 'add' with value 5, score=5, i=1. At i=1: execute 'jump' with value 2, i=3. At i=3: execute 'jump' with value -2, i=1. At i=1: already visited, stop. Return score=5.

example_2.py — Out of Bounds

$ Input: instructions = ["add", "add", "jump"], values = [1, 2, 10]

› Output: 3

💡 Note: Start at i=0: execute 'add' with value 1, score=1, i=1. At i=1: execute 'add' with value 2, score=3, i=2. At i=2: execute 'jump' with value 10, i=12. i=12 is out of bounds, stop. Return score=3.

example_3.py — Single Instruction

$ Input: instructions = ["jump"], values = [1]

› Output: 0

💡 Note: Start at i=0: execute 'jump' with value 1, i=1. i=1 is out of bounds, stop. Return score=0 (no adds were executed).

Visualization

Tap to expand

Understanding the Visualization

Initialize

Set up instruction pointer at 0, score at 0, and empty visited set

Check Bounds

Verify instruction pointer is within valid range

Detect Cycle

Check if current position was visited before using HashSet

Execute

Process the instruction: add to score or jump to new position

Update State

Mark current position as visited and update pointer

Repeat

Continue until out of bounds or cycle detected

Key Takeaway

🎯 Key Insight: Use a HashSet for O(1) cycle detection during instruction simulation - this prevents infinite loops while maintaining optimal performance!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each instruction is visited at most once, O(1) set operations

✓ Linear Growth

Space Complexity

O(n)

HashSet stores at most n visited indices

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
instructions[i] is either "add" or "jump"
-1000 ≤ values[i] ≤ 1000
The arrays instructions and values have the same length

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a HashSet for O(1) cycle detection while simulating the instruction execution. We track visited indices and follow the add/jump rules until we either go out of bounds or detect a cycle by revisiting a previously executed instruction.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Set Simulation (Optimal)	O(n)	O(n)	Use HashSet for O(1) visited lookup during simulation
Brute Force (Array for Visited)	O(n)	O(n)	Use an array to track visited indices, checking linearly each time

Hash Set Simulation (Optimal) — Algorithm Steps

Initialize score = 0, index = 0, and empty HashSet for visited indices
While index is in bounds:
If current index already visited, break (cycle detected)
Add current index to visited set
If instruction is 'add': add value to score, increment index
If instruction is 'jump': update index to current + value
Return final score

Visualization

Tap to expand

Step-by-Step Walkthrough

Check

O(1) lookup in HashSet for current index

Add

Add current index to visited set

Execute

Process instruction and update score/index

Continue

Repeat until out of bounds or cycle found

Code -

solution.c — C

#include <stdbool.h>
#include <stdlib.h>

typedef struct {
    int* keys;
    int size;
    int capacity;
} HashSet;

HashSet* createHashSet(int capacity) {
    HashSet* set = malloc(sizeof(HashSet));
    set->keys = malloc(capacity * sizeof(int));
    set->size = 0;
    set->capacity = capacity;
    return set;
}

bool contains(HashSet* set, int key) {
    for (int i = 0; i < set->size; i++) {
        if (set->keys[i] == key) return true;
    }
    return false;
}

void add(HashSet* set, int key) {
    if (!contains(set, key)) {
        set->keys[set->size++] = key;
    }
}

int calculateScore(char** instructions, int instructionsSize, int* values, int valuesSize) {
    HashSet* visited = createHashSet(instructionsSize);
    int score = 0;
    int i = 0;
    
    while (i >= 0 && i < instructionsSize) {
        if (contains(visited, i)) {
            break;
        }
        
        add(visited, i);
        
        if (strcmp(instructions[i], "add") == 0) {
            score += values[i];
            i++;
        } else { // jump
            i += values[i];
        }
    }
    
    free(visited->keys);
    free(visited);
    return score;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each instruction is visited at most once, O(1) set operations

✓ Linear Growth

Space Complexity

O(n)

HashSet stores at most n visited indices

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
instructions[i] is either "add" or "jump"
-1000 ≤ values[i] ≤ 1000
The arrays instructions and values have the same length

23.5K Views

Medium Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Set Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler