What is the simplest way to solve Check If Digits Are Equal in String After Operations I?

Use simulation. Repeatedly replace the string with adjacent digit sums modulo 10 until only two digits remain, then return whether those two digits are equal.

Why is Math plus String the right pattern for this problem?

Each step reads neighboring characters from a string-like sequence and applies small digit arithmetic. There is no need for greedy logic, dynamic programming, or graph processing.

Can this problem be solved in linear time?

For this Easy version, quadratic simulation is already sufficient because the string length is at most 100. There are math-based observations involving combinatorial weights, but they are unnecessary for the required constraints.

What causes wrong answers most often here?

The biggest mistakes are forgetting modulo 10, updating digits in place incorrectly, and stopping before the sequence has exactly two digits. Those errors usually fail small custom examples immediately.

How do I verify the example s = "3902"?

Start with digits 3, 9, 0, 2. The next row is 2, 9, 2 because 3 + 9 = 12, 9 + 0 = 9, and 0 + 2 = 2, all modulo 10; then 2 + 9 = 1 and 9 + 2 = 1, so the final two digits are equal.

#3461

Easy

auto_awesome数学·string

LeetCode 题解工作台

判断操作后字符串中的数字是否相等 I

给你一个由数字组成的字符串 s 。重复执行以下操作，直到字符串恰好包含两个数字：从第一个数字开始，对于 s 中的每一对连续数字，计算这两个数字的和模 10。用计算得到的新数字依次替换 s 的每一个字符，并保持原本的顺序。如果 s 最后剩下的两个数字相同，返回 true 。否则，返回 …

数学字符串模拟组合数学数论

题目描述

给你一个由数字组成的字符串 s 。重复执行以下操作，直到字符串恰好包含两个数字：

从第一个数字开始，对于 s 中的每一对连续数字，计算这两个数字的和模 10。
用计算得到的新数字依次替换 s 的每一个字符，并保持原本的顺序。

如果 s 最后剩下的两个数字相同，返回 true 。否则，返回 false。

示例 1：

输入： s = "3902"

输出： true

解释：

一开始，s = "3902"
第一次操作：
- (s[0] + s[1]) % 10 = (3 + 9) % 10 = 2
- (s[1] + s[2]) % 10 = (9 + 0) % 10 = 9
- (s[2] + s[3]) % 10 = (0 + 2) % 10 = 2
- s 变为 "292"
第二次操作：
- (s[0] + s[1]) % 10 = (2 + 9) % 10 = 1
- (s[1] + s[2]) % 10 = (9 + 2) % 10 = 1
- s 变为 "11"
由于 "11" 中的数字相同，输出为 true。

示例 2：

输入： s = "34789"

输出： false

解释：

一开始，s = "34789"。
第一次操作后，s = "7157"。
第二次操作后，s = "862"。
第三次操作后，s = "48"。
由于 '4' != '8'，输出为 false。

提示：

3 <= s.length <= 100
s 仅由数字组成。

lightbulb

解题思路

方法一：模拟

我们可以模拟题目描述的操作，直到字符串 $s$ 中只剩下两个数字为止，判断这两个数字是否相同。

时间复杂度 $O(n^2)$ ，空间复杂度 $O(n)$ 。其中 $n$ 为字符串 $s$ 的长度。

1

2

3

4

5

6

7

8

9

class Solution:
    def hasSameDigits(self, s: str) -> bool:
        t = list(map(int, s))
        n = len(t)
        for k in range(n - 1, 1, -1):
            for i in range(k):
                t[i] = (t[i] + t[i + 1]) % 10
        return t[0] == t[1]

speed

复杂度分析

指标	值
时间	Depends on the final approach
空间	Depends on the final approach

psychology

面试官常问的追问

外企场景

question_mark
The prompt says to perform the operation repeatedly as described, which strongly signals direct simulation instead of a hidden data structure trick.
question_mark
Math plus String is the right pattern because each new digit comes from local arithmetic on adjacent characters, not from parsing the whole number.
question_mark
An interviewer may watch whether you preserve the exact modulo 10 reduction on every pair, since that is the easiest place to misread the rule.

warning

常见陷阱

外企场景

error
Using normal addition without modulo 10, which breaks cases where adjacent digits sum to 10 or more.
error
Stopping after one pass or comparing the first two digits seen, instead of continuing until the string length is exactly 2.
error
Building the next row in place from left to right without care, which can overwrite digits that are still needed for later adjacent sums in the same round.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Return the final two-digit string instead of a boolean, which keeps the same repeated adjacent-sum simulation.
arrow_right_alt
Change the operation to multiply adjacent digits or use a different modulus, which keeps the shrinking process but changes the arithmetic rule.
arrow_right_alt
Ask for an optimized math derivation of the final digits using combinatorics, which is more relevant in a follow-up than in this Easy version.

help

常见问题

外企场景

继续练习

#3463 判断操作后字符串中的数字是否相等 II #3518 最小回文排列 II #3556 最大质数子字符串之和