Baseball Game

This is the most natural and idiomatic approach for this problem. The operations (+, D, C) all concern the most recently added scores, which follows a Last-In, First-Out (LIFO) principle. A Stack is the perfect data structure for this pattern.

• Initialize an empty Stack<Integer> (or Deque<Integer>).
• Iterate through each operation in the ops array.
• Handle the operation:
  • Case "+": Pop the top element (last). Peek the new top (prev). Push last back. Push last + prev.
  • Case "D": Peek the top element (last). Push 2 * last.
  • Case "C": Pop the top element.
  • Default (number): Parse the string to an integer and push it onto the stack.
• After the loop, iterate through the stack and sum up all its elements.
• Return the sum.

We can use a Stack<Integer> to maintain the record of valid scores. We process each operation one by one.

• For a number, we parse it and push it onto the stack.
• For a '+', we pop the top score, peek at the new top, calculate their sum, then push the first score back, and finally push the sum. This sequence ensures the stack remains correct for subsequent operations.
• For a 'D', we peek at the top score, double it, and push the result onto the stack.
• For a 'C', we simply pop the top score from the stack.

Using a stack makes the code cleaner and more expressive, as the methods (push, pop, peek) directly correspond to the logic of adding, removing, and accessing the most recent score. In modern Java, it's often recommended to use a Deque (like ArrayDeque) as a stack for better performance, as Stack is a legacy synchronized class.

After all operations are processed, we sum up the remaining scores in the stack to get the final result.

import java.util.ArrayDeque;
import java.util.Deque;

class Solution {
    public int calPoints(String[] operations) {
        // ArrayDeque is generally preferred over the legacy Stack class.
        Deque<Integer> stack = new ArrayDeque<>();

        for (String op : operations) {
            switch (op) {
                case "+":
                    int top = stack.pop();
                    int newTop = top + stack.peek();
                    stack.push(top);
                    stack.push(newTop);
                    break;
                case "D":
                    stack.push(2 * stack.peek());
                    break;
                case "C":
                    stack.pop();
                    break;
                default:
                    stack.push(Integer.parseInt(op));
                    break;
            }
        }

        int sum = 0;
        for (int score : stack) {
            sum += score;
        }
        return sum;
    }
}