Calculate Digit Sum of a String - Practice Coding Problems

Calculate Digit Sum of a String - Problem

String Simulation Easy

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

Your task is to repeatedly process the string in rounds until its length becomes ≤ k. Each round involves:

Divide the string into consecutive groups of size k (the last group may be smaller)
Replace each group with the sum of its digits. For example, "346" becomes "13" (3+4+6=13)
Merge all groups to form a new string
Repeat if the new string length > k

Think of it like condensing a long number by repeatedly summing chunks until it fits your desired size!

Example: If s="11111222223" and k=3, we get groups ["111", "112", "222", "23"], which become ["3", "4", "6", "5"], merged as "3465". Since len("3465") > 3, we continue...

Input & Output

example_1.py — Python

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

› Output: "135"

💡 Note: Round 1: Groups ["111","112","222","23"] become [3,4,6,5] → "3465". Round 2: Groups ["346","5"] become [13,5] → "135". Since len("135") = 3 ≤ k, we stop.

example_2.py — Python

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

› Output: "000"

💡 Note: Round 1: Groups ["000","000","00"] become [0,0,0] → "000". Since len("000") = 3 ≤ k, we stop.

example_3.py — Python

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

› Output: "123"

💡 Note: Since len("123") = 3 ≤ k, no processing needed. Return original string.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with a long string of digits that exceeds our size limit k

Group Formation

Divide the string into consecutive groups of size k (last group may be smaller)

Digit Summation

Calculate the sum of all digits in each group

Compression

Replace each group with its digit sum, creating a shorter string

Iteration Check

If the new string is still too long, repeat the process

Key Takeaway

🎯 Key Insight: The string length reduces dramatically in each round (typically by factor of k/2 or more), making this algorithm very efficient with O(n) total time complexity despite the iterative nature.

Time & Space Complexity

Time Complexity

⏱️

O(n)

While we have rounds, each character is processed a constant number of times since string length reduces dramatically each round

✓ Linear Growth

Space Complexity

O(n)

Space for storing intermediate strings during processing

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ 100
s consists of only digits
k ≤ s.length (at least one round is possible if needed)

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses iterative simulation to process the string in rounds. In each round, we group consecutive characters of size k, calculate digit sums, and merge results. The process continues until string length ≤ k. Time complexity is O(n) since each character is processed a constant number of times as the string shrinks rapidly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n)	O(n)	Simulate each round by creating groups, calculating sums, and rebuilding the string

Brute Force Simulation — Algorithm Steps

Check if string length > k, if not return the string
Create groups of consecutive characters of size k
For each group, sum all digits and convert sum to string
Concatenate all sum strings to form new string
Repeat from step 1 with the new string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original string s and group size k

Group Division

Divide string into consecutive groups of size k

Digit Sum Calculation

Calculate sum of digits for each group

String Reconstruction

Merge all sums to form new string

Length Check

Check if new string length > k, repeat if necessary

Code -

solution.c — C

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

char* digitSum(char* s, int k) {
    int len = strlen(s);
    char* result = (char*)malloc(1000 * sizeof(char));
    strcpy(result, s);
    
    while (strlen(result) > k) {
        char* newS = (char*)malloc(1000 * sizeof(char));
        newS[0] = '\0';
        int currentLen = strlen(result);
        
        // Process string in groups of size k
        for (int i = 0; i < currentLen; i += k) {
            int sum = 0;
            int groupEnd = (i + k < currentLen) ? i + k : currentLen;
            // Calculate sum of digits in this group
            for (int j = i; j < groupEnd; j++) {
                sum += result[j] - '0';
            }
            char sumStr[20];
            sprintf(sumStr, "%d", sum);
            strcat(newS, sumStr);
        }
        strcpy(result, newS);
        free(newS);
    }
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

While we have rounds, each character is processed a constant number of times since string length reduces dramatically each round

✓ Linear Growth

Space Complexity

O(n)

Space for storing intermediate strings during processing

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ 100
s consists of only digits
k ≤ s.length (at least one round is possible if needed)

28.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler