Calculate Digit Sum of a String

Calculate Digit Sum of a String - Problem

String Simulation Easy

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:

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

Input & Output

Example 1 — Basic Case

$ Input: s = "11111222223", k = 3

› Output: "135"

💡 Note: Round 1: "111"|"112"|"222"|"23" → "3"|"4"|"6"|"5" → "3465". Round 2: "346"|"5" → "13"|"5" → "135". Length 3 ≤ k=3, so return "135".

Example 2 — Single Round

$ Input: s = "00000000", k = 3

› Output: "000"

💡 Note: Round 1: "000"|"000"|"00" → "0"|"0"|"0" → "000". Length 3 ≤ k=3, so return "000".

Example 3 — No Processing Needed

$ Input: s = "123", k = 4

› Output: "123"

💡 Note: Length 3 ≤ k=4, so no rounds needed. Return original string "123".

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ 100
s consists of only digits

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is to simulate the grouping and digit summing process iteratively until the string becomes short enough. The most efficient approach uses StringBuilder for string concatenation. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n) Space: O(n)

Follow the problem description exactly: keep dividing into groups, sum digits in each group, concatenate results, and repeat until string length <= k.

Optimized String Building

⏱️ Time: O(n) Space: O(n)

Same logic as brute force but uses more efficient string building techniques to avoid repeated string allocation and copying.

Brute Force Simulation — Algorithm Steps

Step 1: While string length > k, divide into groups of size k
Step 2: For each group, calculate sum of digits
Step 3: Concatenate all sums to form new string
Step 4: Repeat until length <= k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the input string

Group and Sum

Divide into groups of k and sum each group

Repeat

Continue until string length <= k

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(char* s, int k) {
    char* current = malloc(strlen(s) + 1);
    strcpy(current, s);
    
    while (strlen(current) > k) {
        char* newS = malloc(1000);
        newS[0] = '\0';
        int len = strlen(current);
        
        for (int i = 0; i < len; i += k) {
            int digitSum = 0;
            int groupEnd = (i + k < len) ? i + k : len;
            
            for (int j = i; j < groupEnd; j++) {
                digitSum += current[j] - '0';
            }
            
            char sumStr[20];
            sprintf(sumStr, "%d", digitSum);
            strcat(newS, sumStr);
        }
        
        free(current);
        current = newS;
    }
    
    return current;
}

int main() {
    char s[1000];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    char* result = solution(s, k);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is processed a constant number of times across all rounds

✓ Linear Growth

Space Complexity

O(n)

String concatenation creates new strings during processing

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler