2011. 执行操作后的变量最终值

Easy

题目描述

有一种编程语言只有四种操作和一个变量 X：

• ++X 和 X++ 使变量 X 的值增加 1。
• --X 和 X-- 使变量 X 的值减少 1。

最初，X 的值是 0。

给你一个字符串数组 operations，包含一系列操作，请你返回执行所有操作后 X 的最终值。

示例 1：

输入：operations = ["--X","X++","X++"]
输出：1
解释：操作按下述步骤执行：
最初，X = 0
--X：X 减 1 ，X =  0 - 1 = -1
X++：X 加 1 ，X = -1 + 1 =  0
X++：X 加 1 ，X =  0 + 1 =  1

示例 2：

输入：operations = ["++X","++X","X++"]
输出：3
解释：操作按下述步骤执行：
最初，X = 0
++X：X 加 1 ，X = 0 + 1 = 1
++X：X 加 1 ，X = 1 + 1 = 2
X++：X 加 1 ，X = 2 + 1 = 3

示例 3：

输入：operations = ["X++","++X","--X","X--"]
输出：0
解释：操作按下述步骤执行：
最初，X = 0
X++：X 加 1 ，X = 0 + 1 = 1
++X：X 加 1 ，X = 1 + 1 = 2
--X：X 减 1 ，X = 2 - 1 = 1
X--：X 减 1 ，X = 1 - 1 = 0

提示：

• 1 <= operations.length <= 100
• operations[i] 只能是 "++X"、"X++"、"--X" 或 "X--"

解题思路

这是一道简单的模拟题，核心思路是识别四种操作并正确累加结果。

解题思路：

1. 观察操作特点：虽然有四种操作符，但实际上只有两种效果：加1和减1。前缀和后缀的区别在实际编程中体现在返回值上，但这里只关心最终值，所以效果相同。

2. 简化判断：

   • 包含 "++" 的操作：变量加1
   • 包含 "--" 的操作：变量减1

3. 优化方案：可以通过检查字符串中的特定字符来判断操作类型，比如检查第二个字符是否为 '+' 或者直接统计 "++" 和 "--" 的出现次数。

算法步骤：

1. 初始化变量 X 为 0
2. 遍历所有操作字符串
3. 根据操作类型更新 X 的值
4. 返回最终结果

这种方法时间复杂度为 O(n)，空间复杂度为 O(1)，是最直观且高效的解法。

代码实现

class Solution {
public:
    int finalValueAfterOperations(vector<string>& operations) {
        int x = 0;
        for (const string& op : operations) {
            if (op[1] == '+') {
                x++;
            } else {
                x--;
            }
        }
        return x;
    }
};

class Solution:
    def finalValueAfterOperations(self, operations: List[str]) -> int:
        x = 0
        for op in operations:
            if '+' in op:
                x += 1
            else:
                x -= 1
        return x

public class Solution {
    public int FinalValueAfterOperations(string[] operations) {
        int x = 0;
        foreach (string op in operations) {
            if (op[1] == '+') {
                x++;
            } else {
                x--;
            }
        }
        return x;
    }
}

var finalValueAfterOperations = function(operations) {
    let x = 0;
    for (const op of operations) {
        if (op[1]

复杂度分析