Sum of Digits of String After Convert - Practice Coding Problems

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

Understanding the Visualization

Input

String s and number of transformations k

Convert

Replace letters with alphabet positions

Transform

Sum digits k times

Key Takeaway

🎯 Key Insight: Sum digits during conversion to avoid large number arithmetic

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

Approach	Time	Space	Notes
✓ String Concatenation Approach	O(n + k * m)	O(m)	Build the full number string first, then repeatedly sum digits k times
Direct Digit Sum Approach	O(n + k * log(result))	O(1)	Sum digits while converting letters, avoiding large number creation

String Concatenation Approach — Algorithm Steps

Convert each letter to alphabet position (a=1, b=2, ...)
Concatenate all numbers into one string
For k iterations, sum all digits of current number

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Letters

Replace each letter with alphabet position

Build Number

Concatenate all positions into one large number

Sum Digits k Times

Repeatedly sum digits k iterations

Code -

solution.c — C

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

int solution(char* s, int k) {
    // Convert string to number by replacing letters with positions
    char numStr[10000] = "";
    char temp[10];
    
    for (int i = 0; s[i]; i++) {
        sprintf(temp, "%d", s[i] - 'a' + 1);
        strcat(numStr, temp);
    }
    
    // Perform k transformations
    long long current = atoll(numStr);
    for (int i = 0; i < k; i++) {
        int digitSum = 0;
        while (current > 0) {
            digitSum += current % 10;
            current /= 10;
        }
        current = digitSum;
    }
    
    return (int) current;
}

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 * m)

n for initial conversion, k iterations each taking m time where m is number of digits

✓ Linear Growth

Space Complexity

O(m)

Store the number as string, m is the number of digits

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

String Concatenation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler