LeetCode 2243. Calculate Digit Sum of a String Solution in Java, C++, Python & More | Explanation + Code

Description

You are given a string s consisting of digits and an integer k.

A round can be completed if the length of s is greater than k. In one round, do the following:

1. Divide s into consecutive groups of size k such that the first k characters are in the first group, the next k characters are in the second group, and so on. Note that the size of the last group can be smaller than k.
2. Replace each group of s with a string representing the sum of all its digits. For example, "346" is replaced with "13" because 3 + 4 + 6 = 13.
3. Merge consecutive groups together to form a new string. If the length of the string is greater than k, repeat from step 1.

Return s after all rounds have been completed.

 

Example 1:

Input: s = "11111222223", k = 3
Output: "135"
Explanation: 
- 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"
Explanation: 
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.

Solutions

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.

The time complexity is O(n), and the space complexity is O(n). Where n is the length of the string s.

PythonJavaC++GoTypeScriptRustJavaScript

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(code-box)

class Solution { public String digitSum(String s, int k) { while (s.length() > k) { int n = s.length(); StringBuilder t = new StringBuilder(); for (int i = 0; i < n; i += k) { int x = 0; for (int j = i; j < Math.min(i + k, n); ++j) { x += s.charAt(j) - '0'; } t.append(x); } s = t.toString(); } return s; } }(code-box)

class Solution { public: string digitSum(string s, int k) { while (s.size() > k) { string t; int n = s.size(); for (int i = 0; i < n; i += k) { int x = 0; for (int j = i; j < min(i + k, n); ++j) { x += s[j] - '0'; } t += to_string(x); } s = t; } return s; } };(code-box)

func digitSum(s string, k int) string { for len(s) > k { t := &strings.Builder{} n := len(s) for i := 0; i < n; i += k { x := 0 for j := i; j < i+k && j < n; j++ { x += int(s[j] - '0') } t.WriteString(strconv.Itoa(x)) } s = t.String() } return s }(code-box)

function digitSum(s: string, k: number): string { while (s.length > k) { const t: number[] = []; for (let i = 0; i < s.length; i += k) { const x = s .slice(i, i + k) .split('') .reduce((a, b) => a + +b, 0); t.push(x); } s = t.join(''); } return s; }(code-box)

impl Solution { pub fn digit_sum(s: String, k: i32) -> String { let mut s = s; let k = k as usize; while s.len() > k { let mut t = Vec::new(); for chunk in s.as_bytes().chunks(k) { let sum: i32 = chunk.iter().map(|&c| (c - b'0') as i32).sum(); t.push(sum.to_string()); } s = t.join(""); } s } }(code-box)

/** * @param {string} s * @param {number} k * @return {string} */ var digitSum = function (s, k) { while (s.length > k) { const t = []; for (let i = 0; i < s.length; i += k) { const x = s .slice(i, i + k) .split('') .reduce((a, b) => a + +b, 0); t.push(x); } s = t.join(''); } return s; };(code-box)