#2243

Easy

LeetCode Problem Workspace

Calculate Digit Sum of a String

Learn how to repeatedly sum digit groups in a string until its length is at most k using string simulation techniques.

Problem Statement

Given a string s consisting of digits and an integer k, perform repeated rounds of digit sum calculation. In each round, divide s into consecutive groups of length k (the last group may be shorter) and replace each group with the sum of its digits concatenated as a string.

Continue these rounds until the length of s becomes less than or equal to k. Return the resulting string after all rounds are complete. For example, starting with s = "11111222223" and k = 3, the process produces "3465" after the first round and "135" after the second round.

Examples

Example 1

Input: s = "11111222223", k = 3

Output: "135"

For the first round, we divide s into groups of size 3: "111", "112", "222", and "23". Then we calculate the digit sum of each group: 1 + 1 + 1 = 3, 1 + 1 + 2 = 4, 2 + 2 + 2 = 6, and 2 + 3 = 5. So, s becomes "3" + "4" + "6" + "5" = "3465" after the first round.
For the second round, we divide s into "346" and "5". Then we calculate the digit sum of each group: 3 + 4 + 6 = 13, 5 = 5. So, s becomes "13" + "5" = "135" after second round. Now, s.length <= k, so we return "135" as the answer.

Example 2

Input: s = "00000000", k = 3

Output: "000"

We divide s into "000", "000", and "00". Then we calculate the digit sum of each group: 0 + 0 + 0 = 0, 0 + 0 + 0 = 0, and 0 + 0 = 0. s becomes "0" + "0" + "0" = "000", whose length is equal to k, so we return "000".

Constraints

1 <= s.length <= 100
2 <= k <= 100
s consists of digits only.

Solution Approach

Simulate rounds explicitly

Iterate while s.length > k, splitting s into consecutive substrings of length k and computing the digit sum for each. Concatenate the results to form the new s. This approach directly follows the problem pattern and avoids mistakes from partial sums.

Use integer conversion carefully

Convert each character to an integer when summing the digits to prevent string concatenation errors. Always concatenate the digit sums as strings after summing each group to maintain correctness across rounds.

Optimize for repeated rounds

After each round, check if the length of s is <= k. Stop the simulation once the string is short enough to avoid unnecessary computation. This prevents failure due to extra iterations and keeps time complexity under control for inputs up to length 100.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time 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.

What Interviewers Usually Probe

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

Common Pitfalls or Variants

Common pitfalls

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

Follow-up variants

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

FAQ

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.

terminal

Solution

Solution 1: Simulation

According to the problem statement, we can simulate the operations described in the problem until the length of the string is less than or equal to $k$. Finally, return the string.

1

2

3

4

5

6

7

8

9

10

11

12

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

Continue Practicing

#2211 count collisions on a road #2296 design a text editor #2138 divide a string into groups of size k