What is the main approach for Final Value of Variable After Performing Operations?

Iterate through the operations array, applying increments or decrements to X based on the string content, ensuring all operations are executed sequentially.

Does it matter if the operation is '++X' or 'X++'?

No, for the final value of X, both forms have the same net effect, so either increments X by 1 immediately.

Can we optimize without simulating each operation?

Yes, you can count total increments and decrements in a single pass and compute final X as the difference.

What is the time complexity of this solution?

The solution runs in O(n) time where n is the length of the operations array, since each operation is processed once.

How does the Array plus String pattern affect this problem?

The pattern shows that the array drives processing while string content determines the update, making string parsing central to computing X.

#2011

Easy

auto_awesome数组·string

LeetCode 题解工作台

执行操作后的变量值

存在一种仅支持 4 种操作和 1 个变量 X 的编程语言： ++X 和 X++ 使变量 X 的值加 1 --X 和 X-- 使变量 X 的值减 1 最初， X 的值是 0 给你一个字符串数组 operations ，这是由操作组成的一个列表，返回执行所有操作后， X 的最终值。示例 1： …

数组字符串模拟

题目描述

存在一种仅支持 4 种操作和 1 个变量 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--"

lightbulb

解题思路

方法一：计数

我们遍历数组 $\textit{operations}$ ，对于每个操作 $\textit{operations}[i]$ ，如果包含 '+'，那么答案加 $1$ ，否则答案减 $1$ 。

时间复杂度 $O(n)$ ，其中 $n$ 为数组 $\textit{operations}$ 的长度。空间复杂度 $O(1)$ 。

1

2

3

4

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

speed

复杂度分析

指标	值
时间	complexity is O(n) since we process each operation once. Space complexity is O(1) because we only maintain the variable X and no additional structures.
空间	Depends on the final approach

psychology

面试官常问的追问

外企场景

question_mark
Check if candidates properly handle both pre- and post-increment forms equivalently.
question_mark
Watch for solutions that overcomplicate with extra arrays or maps instead of simple counters.
question_mark
Notice if they iterate multiple times unnecessarily rather than a single linear pass.

warning

常见陷阱

外企场景

error
Miscounting X when confusing pre-increment (++X) and post-increment (X++) forms.
error
Using extra data structures which are unnecessary and increase space complexity.
error
Failing to process the operations in order, which can lead to incorrect final X.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Operations could include different variable names, requiring mapping from names to values.
arrow_right_alt
Allowing multi-step operations like 'X+=2' or 'X-=3', extending the simulation approach.
arrow_right_alt
Instead of returning final X, return an array of X after each operation for step-by-step tracking.

help

常见问题

外企场景

继续练习

#2056 棋盘上有效移动组合的数目 #2109 向字符串添加空格 #1324 竖直打印单词