---
# System prepended metadata

title: Leetcode 682. Baseball Game
tags: [Leetcode]

---

---
###### tags: `Leetcode`
---
# Leetcode 682. Baseball Game


[link](https://leetcode.com/problems/baseball-game/)

---

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 ith 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.


#### Example 1:

```
Input: ops = ["5","2","C","D","+"]
Output: 30
Explanation:
"5" - Add 5 to the record, record is now [5].
"2" - Add 2 to the record, record is now [5, 2].
"C" - Invalidate and remove the previous score, record is now [5].
"D" - Add 2 * 5 = 10 to the record, record is now [5, 10].
"+" - Add 5 + 10 = 15 to the record, record is now [5, 10, 15].
The total sum is 5 + 10 + 15 = 30.
```

#### Example 2:

```
Input: ops = ["5","-2","4","C","D","9","+","+"]
Output: 27
Explanation:
"5" - Add 5 to the record, record is now [5].
"-2" - Add -2 to the record, record is now [5, -2].
"4" - Add 4 to the record, record is now [5, -2, 4].
"C" - Invalidate and remove the previous score, record is now [5, -2].
"D" - Add 2 * -2 = -4 to the record, record is now [5, -2, -4].
"9" - Add 9 to the record, record is now [5, -2, -4, 9].
"+" - Add -4 + 9 = 5 to the record, record is now [5, -2, -4, 9, 5].
"+" - Add 9 + 5 = 14 to the record, record is now [5, -2, -4, 9, 5, 14].
The total sum is 5 + -2 + -4 + 9 + 5 + 14 = 27.
```

#### Example 3:

```
Input: ops = ["1","C"]
Output: 0
Explanation:
"1" - Add 1 to the record, record is now [1].
"C" - Invalidate and remove the previous score, record is now [].
Since the record is empty, the total sum is 0.
```


#### Constraints:

- 1 <= operations.length <= 1000
- operations[i] is "C", "D", "+", or a string representing an integer in the range [-3 * 104, 3 * 104].
- 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.

---

The provided code defines a class called Solution with a method calPoints. This method takes a list of strings called operations as input and returns an integer.

The purpose of the calPoints method is to calculate the total sum of points in a game of baseball, based on the given operations. The operations list consists of three types of strings:

'C': This operation represents an invalid round, and it requires removing the last valid score from the record. In the code, if the current operation is 'C', the last element is removed from the r list using the pop() method.

'D': This operation represents doubling the score of the previous round and adding it to the record. In the code, if the current operation is 'D', the double of the last element is appended to the r list.

'+': This operation represents summing the scores of the previous two rounds and adding it to the record. In the code, if the current operation is '+, the sum of the last two elements is appended to the r list.

Any other string: In this case, the string represents a valid score that needs to be added to the record. In the code, the string is converted to an integer using int(operations[i]) and then appended to the r list.

Finally, the method returns the sum of all the elements in the r list, which represents the total sum of points in the baseball game.

#### Solution 1
```python=
class Solution:
    def calPoints(self, operations: List[str]) -> int:
        if not operations:
            return 0

        r = []
        for i in range(len(operations)):
            if operations[i] == 'C':
                r.pop()
            
            elif operations[i] == 'D':
                r.append(r[-1] * 2)

            elif operations[i] == '+':
                r.append(r[-1] + r[-2])

            else: 
                r.append(int(operations[i]))
        
        return sum(r)
                    
        
```
