Baseball Game

Baseball Game - Problem

You are keeping the scores for a baseball game with strange rules. At the beginning of the game, you start with an empty record.

You are given a list of strings operations, where operations[i] is the i-th operation you must apply to the record and is one of the following:

An integer x - Record a new score of x
'+' - Record a new score that is the sum of the previous two scores
'D' - Record a new score that is the double of the previous score
'C' - Invalidate the previous score, removing it from the record

Return the sum of all the scores on the record after applying all the operations.

The test cases are generated such that the answer and all intermediate calculations fit in a 32-bit integer and that all operations are valid.

Input & Output

Example 1 — Mixed Operations

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

› Output: 30

💡 Note: "5" → [5], "2" → [5,2], "C" → [5], "D" → [5,10], "+" → [5,10,15]. Sum = 5+10+15 = 30

Example 2 — Simple Numbers

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

› Output: 27

💡 Note: "5" → [5], "-2" → [5,-2], "4" → [5,-2,4], "C" → [5,-2], "D" → [5,-2,-4], "9" → [5,-2,-4,9], "+" → [5,-2,-4,9,5], "+" → [5,-2,-4,9,5,14]. Sum = 27

Example 3 — Only Numbers

$ Input: operations = ["1"]

› Output: 1

💡 Note: Single operation adds 1 to record. Sum = 1

Constraints

1 ≤ operations.length ≤ 1000
operations[i] is "C", "D", "+", or a string representing an integer in range [-3 × 10⁴, 3 × 10⁴]
For operation "+", there will always be at least two previous scores on the record
For operations "C" and "D", there will always be at least one previous score on the record

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8 f Facebook 5

The key insight is to use a stack data structure to efficiently handle the last-in operations (cancel, double, sum of previous two). Best approach is the stack method with single pass processing. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force with List

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

Maintain a list of valid scores. For each operation, modify the list accordingly and recalculate the total sum. This approach recalculates the sum from scratch after every operation.

Optimized Stack Approach

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

Use a stack data structure to store valid scores. Process each operation by pushing/popping from the stack. Calculate the final sum only once at the end, avoiding redundant calculations.

Brute Force with List — Algorithm Steps

Initialize empty list for scores
For each operation: modify list based on type
Recalculate sum from all elements after each operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Operations

Handle each operation and modify the scores list

Recalculate Sum

Sum all valid scores after each operation

Final Result

Return the final sum

Code -

solution.c — C

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

int evaluateSimple(char* expr) {
    int len = strlen(expr);
    if (len == 0) return 0;
    
    int numbers[1000];
    char operators[1000];
    int numCount = 0, opCount = 0;
    int i = 0;
    
    // Handle leading negative
    if (i < len && expr[i] == '-') {
        numbers[numCount++] = 0;
        operators[opCount++] = '-';
        i++;
    }
    
    while (i < len) {
        if (isdigit(expr[i])) {
            int num = 0;
            while (i < len && isdigit(expr[i])) {
                num = num * 10 + (expr[i] - '0');
                i++;
            }
            numbers[numCount++] = num;
        } else if (expr[i] != ' ') {
            operators[opCount++] = expr[i];
            i++;
        } else {
            i++;
        }
    }
    
    // Handle * and /
    int j = 0;
    while (j < opCount) {
        if (operators[j] == '*') {
            numbers[j] = numbers[j] * numbers[j + 1];
            for (int k = j + 1; k < numCount - 1; k++) {
                numbers[k] = numbers[k + 1];
            }
            for (int k = j; k < opCount - 1; k++) {
                operators[k] = operators[k + 1];
            }
            numCount--;
            opCount--;
        } else if (operators[j] == '/') {
            numbers[j] = numbers[j] / numbers[j + 1];
            for (int k = j + 1; k < numCount - 1; k++) {
                numbers[k] = numbers[k + 1];
            }
            for (int k = j; k < opCount - 1; k++) {
                operators[k] = operators[k + 1];
            }
            numCount--;
            opCount--;
        } else {
            j++;
        }
    }
    
    // Handle + and -
    int result = numbers[0];
    for (int k = 0; k < opCount; k++) {
        if (operators[k] == '+') {
            result += numbers[k + 1];
        } else {
            result -= numbers[k + 1];
        }
    }
    
    return result;
}

char* solveRecursive(char* expr) {
    char* result = malloc(1000);
    char* parenPos = strchr(expr, '(');
    
    if (parenPos == NULL) {
        sprintf(result, "%d", evaluateSimple(expr));
        return result;
    }
    
    int start = -1;
    int len = strlen(expr);
    for (int i = 0; i < len; i++) {
        if (expr[i] == '(') {
            start = i;
        } else if (expr[i] == ')') {
            char inner[1000];
            strncpy(inner, expr + start + 1, i - start - 1);
            inner[i - start - 1] = '\0';
            
            int innerResult = evaluateSimple(inner);
            
            char* newExpr = malloc(1000);
            strncpy(newExpr, expr, start);
            newExpr[start] = '\0';
            sprintf(newExpr + start, "%d%s", innerResult, expr + i + 1);
            
            char* finalResult = solveRecursive(newExpr);
            free(newExpr);
            free(result);
            return finalResult;
        }
    }
    
    sprintf(result, "%d", evaluateSimple(expr));
    return result;
}

int solution(char* s) {
    char* resultStr = solveRecursive(s);
    int result = atoi(resultStr);
    free(resultStr);
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n operations, we potentially sum all elements (up to n elements)

⚠ Quadratic Growth

Space Complexity

O(n)

List stores up to n valid scores

⚡ Linearithmic Space

285.0K Views

Medium Frequency

~15 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler