跳转至

3921. 分数验证器

题目描述

给你一个字符串数组 events。

一开始，score = 0 且 counter = 0。events 中的每个元素为以下之一：

  • "0", "1", "2", "3", "4", "6"：将该值加到总得分中。
  • "W"：计数器加 1。不增加得分。
  • "WD"：总得分加 1。
  • "NB"：总得分加 1。

从左到右处理数组。当满足以下任一条件时停止处理：

  • events 中的所有元素都已处理完毕，或
  • 计数器变为 10。

返回一个整数数组 [score, counter]，其中：

  • score 是最终的总得分。
  • counter 是最终的计数器值。

 

示例 1：

输入： events = ["1","4","W","6","WD"]

输出： [12,1]

解释：

事件 得分 计数器
"1" 1 0
"4" 5 0
"W" 5 1
"6" 11 1
"WD" 12 1

最终结果：[12, 1]。

示例 2：

输入： events = ["WD","NB","0","4","4"]

输出： [10,0]

解释：

事件 得分 计数器
"WD" 1 0
"NB" 2 0
"0" 2 0
"4" 6 0
"4" 10 0

最终结果：[10, 0]。

示例 3：

输入： events = ["W","W","W","W","W","W","W","W","W","W","W"]

输出： [0,10]

解释：

出现 10 次 "W" 后，计数器达到 10，因此停止处理。剩余的事件将被忽略。

 

提示：

  • 1 <= events.length <= 1000
  • events[i] 是 "0"、"1"、"2"、"3"、"4"、"6"、"W"、"WD" 或 "NB" 之一。

解法

方法一：模拟

我们可以直接模拟题目中描述的过程来计算最终的得分和计数器值。

首先，我们初始化两个变量 \(\textit{score}\) 和 \(\textit{counter}\)，分别表示当前的总得分和计数器值。然后我们遍历数组 \(\textit{events}\) 中的每个事件，根据事件的类型来更新 \(\textit{score}\) 和 \(\textit{counter}\) 的值：

  • 如果事件是数字字符串，我们将该数字转换为整数并加到 \(\textit{score}\) 中。
  • 如果事件是字符串 "W"，我们将 \(\textit{counter}\) 加 1，并检查是否达到了 10，如果达到了就停止处理。
  • 否则（事件是 "WD" 或 "NB"），我们将 \(\textit{score}\) 加 1。

在处理完所有事件或者计数器达到 10 后，我们返回一个数组，包含最终的 \(\textit{score}\) 和 \(\textit{counter}\) 的值。

时间复杂度 \(O(n)\)，其中 \(n\) 是数组 \(\textit{events}\) 的长度。空间复杂度 \(O(1)\)，我们只使用了常数级别的额外空间。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Solution:
    def scoreValidator(self, events: list[str]) -> list[int]:
        score = counter = 0
        for event in events:
            if event.isdigit():
                score += int(event)
            elif event == "W":
                counter += 1
                if counter == 10:
                    break
            else:
                score += 1
        return [score, counter]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
class Solution {
    public int[] scoreValidator(String[] events) {
        int score = 0;
        int counter = 0;
        for (String event : events) {
            if (event.matches("\\d+")) {
                score += Integer.parseInt(event);
            } else if (event.equals("W")) {
                if (++counter == 10) {
                    break;
                }
            } else {
                score++;
            }
        }
        return new int[] {score, counter};
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    vector<int> scoreValidator(vector<string>& events) {
        int score = 0;
        int counter = 0;
        for (string event : events) {
            if (isdigit(event[0])) {
                score += stoi(event);
            } else if (event == "W") {
                if (++counter == 10) {
                    break;
                }
            } else {
                score++;
            }
        }
        return {score, counter};
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func scoreValidator(events []string) []int {
    score := 0
    counter := 0
    for _, event := range events {
        if num, err := strconv.Atoi(event); err == nil {
            score += num
        } else if event == "W" {
            counter++
            if counter == 10 {
                break
            }
        } else {
            score++
        }
    }
    return []int{score, counter}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
function scoreValidator(events: string[]): number[] {
    let score = 0;
    let counter = 0;
    for (const event of events) {
        if (/^\d+$/.test(event)) {
            score += parseInt(event);
        } else if (event === 'W') {
            counter++;
            if (counter === 10) {
                break;
            }
        } else {
            score++;
        }
    }
    return [score, counter];
}

评论