What is the main pattern used in Calculate Digit Sum of a String?

The primary pattern is string plus simulation, where you repeatedly split the string into groups and sum digits until length <= k.

How do I handle the last group if it has fewer than k digits?

Treat the last group as normal, sum its digits, and concatenate the result. Do not pad or skip it.

Can this approach handle strings with leading zeros?

Yes, leading zeros are summed as 0 and concatenated correctly. The simulation handles all digit strings uniformly.

When should the rounds stop in this simulation?

Stop when the string length becomes less than or equal to k. Continuing beyond this point is unnecessary.

Is there a faster method than simulating each round?

For this problem's constraints, direct simulation is efficient and simple. Optimizations are minor and rarely needed for n <= 100.

#2243

Easy

auto_awesomestring·结合·模拟

LeetCode 题解工作台

计算字符串的数字和

给你一个由若干数字（ 0 - 9 ）组成的字符串 s ，和一个整数。如果 s 的长度大于 k ，则可以执行一轮操作。在一轮操作中，需要完成以下工作：将 s 拆分成长度为 k 的若干连续数字组，使得前 k 个字符都分在第一组，接下来的 k 个字符都分在第二组，依此类推。注意，最后一个数字…

字符串模拟

题目描述

给你一个由若干数字（0 - 9）组成的字符串 s ，和一个整数。

如果 s 的长度大于 k ，则可以执行一轮操作。在一轮操作中，需要完成以下工作：

将 s 拆分成长度为 k 的若干 连续数字组 ，使得前 k 个字符都分在第一组，接下来的 k 个字符都分在第二组，依此类推。注意，最后一个数字组的长度可以小于 k 。
用表示每个数字组中所有数字之和的字符串来替换对应的数字组。例如，"346" 会替换为 "13" ，因为 3 + 4 + 6 = 13 。
合并所有组以形成一个新字符串。如果新字符串的长度大于 k 则重复第一步。

返回在完成所有轮操作后的 s 。

示例 1：

输入：s = "11111222223", k = 3
输出："135"
解释：
- 第一轮，将 s 分成："111"、"112"、"222" 和 "23" 。
  接着，计算每一组的数字和：1 + 1 + 1 = 3、1 + 1 + 2 = 4、2 + 2 + 2 = 6 和 2 + 3 = 5 。 
  这样，s 在第一轮之后变成 "3" + "4" + "6" + "5" = "3465" 。
- 第二轮，将 s 分成："346" 和 "5" 。
  接着，计算每一组的数字和：3 + 4 + 6 = 13 、5 = 5 。
  这样，s 在第二轮之后变成 "13" + "5" = "135" 。 
现在，s.length <= k ，所以返回 "135" 作为答案。

示例 2：

输入：s = "00000000", k = 3
输出："000"
解释：
将 "000", "000", and "00".
接着，计算每一组的数字和：0 + 0 + 0 = 0 、0 + 0 + 0 = 0 和 0 + 0 = 0 。 
s 变为 "0" + "0" + "0" = "000" ，其长度等于 k ，所以返回 "000" 。

提示：

1 <= s.length <= 100
2 <= k <= 100
s 仅由数字（0 - 9）组成。

lightbulb

解题思路

方法一：模拟

根据题意，我们可以模拟题目中的操作过程，直到字符串长度小于等于 $k$ 为止，最后返回字符串即可。

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

1

2

3

4

5

6

7

8

9

10

11

12

13

class Solution:
    def digitSum(self, s: str, k: int) -> str:
        while len(s) > k:
            t = []
            n = len(s)
            for i in range(0, n, k):
                x = 0
                for j in range(i, min(i + k, n)):
                    x += int(s[j])
                t.append(str(x))
            s = "".join(t)
        return s

speed

复杂度分析

指标	值
时间	complexity depends on the number of rounds needed. Each round processes each digit once, and the number of rounds is O(log(n)) in practice, giving an overall O(n log n) behavior. Space complexity is O(n) for storing the intermediate strings.
空间	Depends on the final approach

psychology

面试官常问的追问

外企场景

question_mark
Ask candidates to simulate rounds explicitly using string and integer operations.
question_mark
Check for correct handling of last group with length less than k.
question_mark
Confirm candidates stop processing when the string length becomes <= k.

warning

常见陷阱

外企场景

error
Concatenating digits without summing them properly per group.
error
Failing to handle the last group if its length is less than k.
error
Continuing rounds even after the string length becomes <= k.

swap_horiz

进阶变体

外企场景

arrow_right_alt
Calculate digit sum using different group sizes dynamically in each round.
arrow_right_alt
Perform the same process but allow non-digit characters that must be ignored.
arrow_right_alt
Return the number of rounds required instead of the final string.

help

常见问题

外企场景

继续练习

#2211 统计道路上的碰撞次数 #2296 设计一个文本编辑器 #2138 将字符串拆分为若干长度为 k 的组