Calculate Score After Performing Instructions

Medium

Asked by:

16 views

Topics:

Arrays

You are given two arrays, instructions and values, both of size n.

You need to simulate a process based on the following rules:

You start at the first instruction at index i = 0 with an initial score of 0.
If instructions[i] is "add":
- Add values[i] to your score.
- Move to the next instruction (i + 1).
If instructions[i] is "jump":
- Move to the instruction at index (i + values[i]) without modifying your score.

The process ends when you either:

Go out of bounds (i.e., i < 0 or i >= n), or
Attempt to revisit an instruction that has been previously executed. The revisited instruction is not executed.

Return your score at the end of the process.

Example 1:

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

Output: 1

Explanation:

Simulate the process starting at instruction 0:

At index 0: Instruction is "jump", move to index 0 + 2 = 2.
At index 2: Instruction is "add", add values[2] = 3 to your score and move to index 3. Your score becomes 3.
At index 3: Instruction is "jump", move to index 3 + 1 = 4.
At index 4: Instruction is "add", add values[4] = -2 to your score and move to index 5. Your score becomes 1.
At index 5: Instruction is "jump", move to index 5 + (-3) = 2.
At index 2: Already visited. The process ends.

Example 2:

Input: instructions = ["jump","add","add"], values = [3,1,1]

Output: 0

Explanation:

Simulate the process starting at instruction 0:

At index 0: Instruction is "jump", move to index 0 + 3 = 3.
At index 3: Out of bounds. The process ends.

Example 3:

Input: instructions = ["jump"], values = [0]

Output: 0

Explanation:

Simulate the process starting at instruction 0:

At index 0: Instruction is "jump", move to index 0 + 0 = 0.
At index 0: Already visited. The process ends.

Constraints:

n == instructions.length == values.length
1 <= n <= 10⁵
instructions[i] is either "add" or "jump".
-10⁵ <= values[i] <= 10⁵

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What are the possible types of instructions, and what operations do they perform on the score?
What is the initial value of the score before any instructions are applied?
Can the instructions array be empty or null?
What are the possible data types and value ranges for the score and any parameters used in the instructions?
If any instruction results in an invalid score (e.g., negative score when it shouldn't be), what should the function return or how should it behave?

Brute Force Solution

Approach

The brute force approach means we will try every single possible sequence of instructions to find the one that gives us the highest score. We will simulate each instruction, update the score, and then try the next instruction sequence.

Here's how the algorithm would work step-by-step:

Start with the initial score and an empty sequence of instructions.
Consider the first instruction. Apply it to the current score and remember the new score.
Then, consider the second instruction, and apply it to the new score we calculated in the previous step. Again, remember the score.
Keep doing this for every possible sequence of the instructions.
After trying every sequence, compare the final scores from each sequence.
Pick the sequence that resulted in the highest final score. That's our answer.

Code Implementation

def calculate_score_brute_force(initial_score, instructions):
    highest_score = float('-inf')

    def generate_instruction_sequences(current_score, current_sequence):
        nonlocal highest_score

        # Base case: When we've used all instructions, update highest score.
        if not instructions:
            highest_score = max(highest_score, current_score)
            return

        for instruction in instructions:
            remaining_instructions = instructions[:]
            remaining_instructions.remove(instruction)
            
            # Apply the instruction to the current score.
            new_score = current_score + instruction
            generate_instruction_sequences(new_score, current_sequence + [instruction])

    generate_instruction_sequences(initial_score, [])
    return highest_score

Big(O) Analysis

Time Complexity

O(m^n) – The brute force approach explores all possible sequences of instructions. If we have 'm' instructions and a sequence of length 'n', each position in the sequence can be filled with any of the 'm' instructions. Therefore, there are m choices for the first instruction, m choices for the second instruction, and so on, up to the nth instruction. This results in m * m * ... * m (n times) total sequences, giving us a time complexity of O(m^n), where 'm' is the number of instructions and 'n' is the length of the sequence to generate.

Space Complexity

O(1) – The brute force approach, as described, doesn't explicitly create any auxiliary data structures like arrays or hash maps to store intermediate results. It focuses on simulating instructions and updating the score in place. The space used is limited to storing the current score and potentially a few variables to iterate through the instructions, which is independent of the number of instructions, N. Thus, the auxiliary space complexity remains constant.

Optimal Solution

Approach

The most efficient way to calculate the score is by simulating the instructions directly. We keep track of the score and the current value, updating them according to each instruction encountered in sequence.

Here's how the algorithm would work step-by-step:

Start with a score of zero and a current value of one.
Read each instruction one at a time, in the order given.
If the instruction is to add, increase the score by the current value, then move to the next instruction.
If the instruction is to double, multiply the current value by two, then move to the next instruction.
Repeat steps three and four until you have processed all instructions.
The final score will be the calculated score after applying all instructions.

Code Implementation

def calculate_score_after_performing_instructions(instructions):
    score = 0
    current_value = 1

    # Iterate through each instruction in the given list
    for instruction in instructions:
        if instruction == "add":
            # Add instruction updates the score
            score += current_value

        elif instruction == "double":
            # Double instruction updates the current value
            current_value *= 2

    # Return the final calculated score
    return score

Big(O) Analysis

Time Complexity

O(n) – The provided solution iterates through the instructions array once. For each instruction, it performs a constant-time operation, either adding to the score or doubling the current value. Therefore, the time complexity is directly proportional to the number of instructions, n. This results in a linear time complexity of O(n).

Space Complexity

O(1) – The algorithm uses a constant amount of extra space. It only requires two variables: one to store the current score and another to store the current value. These variables do not depend on the number of instructions, N. Therefore, the auxiliary space complexity is O(1).

Edge Cases

Case	How to Handle
Null input array	Throw IllegalArgumentException or return a default value (e.g., 0 or -1) after checking for null input.
Empty instructions list	If the instructions list is empty, return the initial score without modification.
Integer overflow in score calculation	Use long data type for score to prevent overflow or check for potential overflows during addition and subtraction.
Invalid instruction type (e.g., not 'add' or 'multiply')	Throw an IllegalArgumentException or skip the instruction and log an error.
Zero value in 'multiply' instruction	Handle multiplication by zero correctly, resulting in a zero score contribution.
Maximum sized input array and instructions list leading to time complexity issues	Ensure algorithm exhibits O(n+m) where n is array length, m is instruction length for large inputs.
Instructions result in score becoming negative	The problem description should state whether negative scores are allowed and the implementation follows that constraint.
Conflicting instructions where an add is followed by an extremely large subtraction	Ensure order of operations is properly followed and data types can handle the large subtractions.

Null input array

How to Handle:

Throw IllegalArgumentException or return a default value (e.g., 0 or -1) after checking for null input.

Empty instructions list

How to Handle:

If the instructions list is empty, return the initial score without modification.

Integer overflow in score calculation

How to Handle:

Use long data type for score to prevent overflow or check for potential overflows during addition and subtraction.

Invalid instruction type (e.g., not 'add' or 'multiply')

How to Handle:

Throw an IllegalArgumentException or skip the instruction and log an error.

Zero value in 'multiply' instruction

How to Handle:

Handle multiplication by zero correctly, resulting in a zero score contribution.

Maximum sized input array and instructions list leading to time complexity issues

How to Handle:

Ensure algorithm exhibits O(n+m) where n is array length, m is instruction length for large inputs.

Instructions result in score becoming negative

How to Handle:

The problem description should state whether negative scores are allowed and the implementation follows that constraint.

Conflicting instructions where an add is followed by an extremely large subtraction

How to Handle:

Ensure order of operations is properly followed and data types can handle the large subtractions.