Baseball Game - Practice Coding Problems

Baseball Game - Problem

You're the scorekeeper for a baseball game with unusual scoring rules! 🥎

Starting with an empty record, you'll process a list of operations where each operation can be:

Integer x: Record a new score of x
'+': Record a new score equal to the sum of the previous two scores
'D': Record a new score that is double the previous score
'C': Cancel the previous score (remove it from the record)

Goal: Return the sum of all scores remaining in the record after applying all operations.

Example: Given operations ["5", "2", "C", "D", "+"]
• Start: []
• "5": [5]
• "2": [5, 2]
• "C": [5] (cancel 2)
• "D": [5, 10] (double 5)
• "+": [5, 10, 15] (5+10)
• Sum: 30

Input & Output

example_1.py — Standard Operations

$ Input: ["5", "2", "C", "D", "+"]

› Output: 30

💡 Note: Start with []. Add 5: [5]. Add 2: [5,2]. Cancel: [5]. Double: [5,10]. Sum last two: [5,10,15]. Total: 5+10+15=30

example_2.py — Multiple Operations

$ Input: ["5", "-2", "4", "C", "D", "9", "+", "+"]

› Output: 27

💡 Note: [5] → [5,-2] → [5,-2,4] → [5,-2] → [5,-2,-4] → [5,-2,-4,9] → [5,-2,-4,9,5] → [5,-2,-4,9,5,14]. Sum: 27

example_3.py — Single Score

$ Input: ["1"]

› Output: 1

💡 Note: Only one score recorded. The sum is simply 1.

Visualization

Tap to expand

Understanding the Visualization

Initialize Empty Stack

Start with an empty stack to hold score cards

Process Each Operation

For numbers: add new card. For 'C': remove top card. For 'D': peek at top, add doubled card. For '+': peek at top two, add sum card

Calculate Final Sum

Add up all remaining score cards in the stack

Key Takeaway

🎯 Key Insight: Stack operations perfectly match this problem's requirements - we only need to access the most recent scores, making it a natural fit for LIFO (Last In, First Out) operations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through operations array, each operation takes O(1) time

✓ Linear Growth

Space Complexity

O(n)

Stack stores at most n scores in worst case

⚡ Linearithmic Space

Constraints

1 ≤ operations.length ≤ 1000
-3 × 10⁴ ≤ x ≤ 3 × 10⁴ for integer operations
All operations are guaranteed to be valid
At most 1000 calls to each operation type

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 15

The stack-based approach is optimal for this problem. Use a stack to store scores, handle operations in O(1) time each: push integers, pop for 'C', peek and push doubled value for 'D', and peek at top two elements for '+'. Finally, sum all remaining stack elements. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Solution (Optimal)	O(n)	O(n)	Use a stack to efficiently handle all operations in one pass
Brute Force (Array with Manual Operations)	O(n)	O(n)	Use a regular array and manually handle all operations with index tracking

Stack-Based Solution (Optimal) — Algorithm Steps

Initialize an empty stack to store valid scores
Iterate through each operation in the list
For integers: convert to int and push onto stack
For 'C': pop the last score from stack
For 'D': peek at top, double it, and push the result
For '+': peek at top two scores, sum them, and push the result
Return the sum of all remaining scores in the stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Push "5"

Stack: [5]

Push "2"

Stack: [5, 2]

Cancel "C"

Stack: [5] (removed 2)

Double "D"

Stack: [5, 10] (5*2=10)

Sum "+"

Stack: [5, 10, 15] (5+10=15)

Code -

solution.c — C

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

int calPoints(char** operations, int operationsSize) {
    int* stack = malloc(operationsSize * sizeof(int));
    int top = -1;
    
    for (int i = 0; i < operationsSize; i++) {
        if (strcmp(operations[i], "C") == 0) {
            top--;  // Pop
        } else if (strcmp(operations[i], "D") == 0) {
            stack[++top] = stack[top-1] * 2;  // Push double
        } else if (strcmp(operations[i], "+") == 0) {
            stack[++top] = stack[top-1] + stack[top-2];  // Push sum
        } else {
            stack[++top] = atoi(operations[i]);  // Push new score
        }
    }
    
    int sum = 0;
    for (int i = 0; i <= top; i++) {
        sum += stack[i];
    }
    
    free(stack);
    return sum;
}

int main() {
    // Parse input and call calPoints
    char* ops[] = {"5", "2", "C", "D", "+"};
    printf("%d\n", calPoints(ops, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through operations array, each operation takes O(1) time

✓ Linear Growth

Space Complexity

O(n)

Stack stores at most n scores in worst case

⚡ Linearithmic Space

Constraints

1 ≤ operations.length ≤ 1000
-3 × 10⁴ ≤ x ≤ 3 × 10⁴ for integer operations
All operations are guaranteed to be valid
At most 1000 calls to each operation type

125.0K Views

Medium Frequency

~15 min Avg. Time

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

Stack-Based Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler