Sum of Digits of String After Convert - Problem

String Simulation Easy

You are given a string s consisting of lowercase English letters, and an integer k. Your task is to convert the string into an integer by a special process, and then transform it by summing its digits repeatedly k times.

More specifically, perform the following steps:

Convert s into an integer by replacing each letter with its position in the alphabet (i.e. replace 'a' with 1, 'b' with 2, ..., 'z' with 26).
Transform the integer by replacing it with the sum of its digits.
Repeat the transform operation (step 2) k times in total.

Example: If s = "zbax" and k = 2, then the resulting integer would be 8 by the following operations:

Convert: "zbax" ➝ "(26)(2)(1)(24)" ➝ "262124" ➝ 262124
Transform #1: 262124 ➝ 2 + 6 + 2 + 1 + 2 + 4 ➝ 17
Transform #2: 17 ➝ 1 + 7 ➝ 8

Return the resulting integer after performing the operations described above.

Input & Output

Example 1 — Basic Case

$ Input: s = "zbax", k = 2

› Output: 8

💡 Note: Convert: z(26) + b(2) + a(1) + x(24) = "262124" → sum digits: 2+6+2+1+2+4=17 → sum again: 1+7=8

Example 2 — Single Character

$ Input: s = "z", k = 1

› Output: 8

💡 Note: Convert: z(26) → sum digits once: 2+6=8

Example 3 — Multiple Transforms

$ Input: s = "leetcode", k = 2

› Output: 6

💡 Note: Convert letters to positions and sum: gets large number → first sum gives 54 → second sum: 5+4=9... final result is 6

Constraints

1 ≤ s.length ≤ 100
1 ≤ k ≤ 10
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to convert letters to alphabet positions and sum digits efficiently. The optimal approach sums digits during conversion rather than building large numbers. Best approach: Direct digit summing. Time: O(n + k * log(result)), Space: O(1)

Common Approaches

✓ Direct Digit Sum Approach

⏱️ Time: O(n + k * log(result)) Space: O(1)

Convert each letter and immediately add its digits to running sum, then perform k-1 more digit sum iterations. This avoids creating potentially very large numbers.

String Concatenation Approach

⏱️ Time: O(n + k * m) Space: O(m)

Convert each letter to its alphabet position, concatenate to form a large number string, then perform k iterations of digit summing.

Direct Digit Sum Approach — Algorithm Steps

For each letter, convert to alphabet position and sum its digits directly
This gives us the first transformation result
Perform k-1 more digit summing iterations

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert & Sum

For each letter, convert and immediately sum its digits

First Sum

Get total from all converted letter digits

Repeat k-1 Times

Continue summing digits k-1 more times

Code -

solution.c — C

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

int solution(char* s, int k) {
    // First transformation: convert letters and sum digits immediately
    int total = 0;
    for (int i = 0; s[i]; i++) {
        int num = s[i] - 'a' + 1;
        // Sum digits of this number
        while (num > 0) {
            total += num % 10;
            num /= 10;
        }
    }
    
    // Perform remaining k-1 transformations
    for (int i = 0; i < k - 1; i++) {
        int newTotal = 0;
        while (total > 0) {
            newTotal += total % 10;
            total /= 10;
        }
        total = newTotal;
    }
    
    return total;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n + k * log(result))

n for processing each letter, k iterations of digit summing where each takes log(result) time

✓ Linear Growth

Space Complexity

O(1)

Only use constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Sum of Digits of String After Convert - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Digit Sum Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler