Skip to main content
Talentd

Sum of Digits of String After Convert - Solution & Explanation

EasyStringSimulation14 min readAsked at: Amazon, Microsoft, Meta +2
Practice this problem

Problem Statement

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:

  1. 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).
  2. Transform the integer by replacing it with the sum of its digits.
  3. Repeat the transform operation (step 2) k times in total.

For example, if s = "zbax" and k = 2, then the resulting integer would be 8 by the following operations:

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

Return the resulting integer after performing the operations described above.

 

Example 1:

Input: s = "iiii", k = 1

Output: 36

Explanation:

The operations are as follows:
- Convert: "iiii" ➝ "(9)(9)(9)(9)" ➝ "9999" ➝ 9999
- Transform #1: 9999 ➝ 9 + 9 + 9 + 9 ➝ 36
Thus the resulting integer is 36.

Example 2:

Input: s = "leetcode", k = 2

Output: 6

Explanation:

The operations are as follows:
- Convert: "leetcode" ➝ "(12)(5)(5)(20)(3)(15)(4)(5)" ➝ "12552031545" ➝ 12552031545
- Transform #1: 12552031545 ➝ 1 + 2 + 5 + 5 + 2 + 0 + 3 + 1 + 5 + 4 + 5 ➝ 33
- Transform #2: 33 ➝ 3 + 3 ➝ 6
Thus the resulting integer is 6.

Example 3:

Input: s = "zbax", k = 2

Output: 8

 

Constraints:

  • 1 <= s.length <= 100
  • 1 <= k <= 10
  • s consists of lowercase English letters.

Approach Overview

Problem Overview: You receive a lowercase string s and an integer k. Each character is converted to its alphabet position (a = 1, b = 2, … z = 26) and concatenated into a numeric string. Then you repeat the digit-sum operation k times. The goal is to return the final integer after these transformations.

Approach 1: Map and Sum Technique (O(n + k * d) time, O(n) space)

This approach directly simulates the process described in the problem. First iterate through the string and convert each character using value = c - 'a' + 1. Append these numbers to build the transformed numeric string. After that, perform the digit-sum operation k times by iterating through the digits and computing their total. The main work comes from scanning the original string once and then processing the digit string repeatedly. This approach is straightforward and mirrors the problem statement, making it easy to implement when practicing string manipulation and simulation.

Approach 2: Direct Digit Sum Accumulation (O(n + k) time, O(1) space)

The key observation: you do not need to build the intermediate numeric string. When converting characters to alphabet positions, immediately split multi-digit values and add their digits to a running sum. For example, z = 26 contributes 2 + 6. This gives the result of the first transformation directly as a digit sum. After that, repeat the digit-sum operation k - 1 times on the resulting number until all iterations are completed. Since only a few digits are processed after the first step, the remaining operations are very small. This optimized simulation avoids storing large strings and keeps space constant while still using simple iteration.

Recommended for interviews: Direct Digit Sum Accumulation is the approach most interviewers expect. It shows you spotted the optimization that eliminates the intermediate string and reduces memory usage. Implementing the basic Map and Sum simulation first demonstrates understanding of the transformation, but the optimized approach proves stronger reasoning with digit manipulation and efficient string processing.

Approach 1: Map and Sum Technique

This approach involves converting each character to its corresponding position in the alphabet and forming a numeric string. We then sum the digits of this number 'k' times to get the resulting integer.

The function sumOfDigitsAfterConvert converts the string s into a numeric representation of alphabet positions. The helper function digitSum computes the sum of digits of a given number string. The transformation step is repeated k times by repeatedly summing the digits of the number string.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(N + kM), where N is the length of the string and M is the number of digits in the transformed number.
Space Complexity: O(M), as we store the transformed number as a string.

Try this approach in the editor →

Approach 2: Direct Digit Sum Accumulation

This approach directly calculates the digit sum during the conversion of the string to a number by aggregating the sum of each digit representation, reducing the need for intermediate large integer string handling.

Here, the conversion and the first summing of digits are done simultaneously using modulo operations. This reduces the need for intermediate storage and allows for direct digit sum transformation.

Code

CC++JavaPythonC#JavaScript

C

C++

Java

Python

C#

JavaScript

Complexity

Time Complexity: O(N + k*logM), where M is the intermediate sum value.
Space Complexity: O(1).

Try this approach in the editor →

Approach 3: Simulation

We can simulate the process described in the problem.

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

Code

PythonJavaC++GoTypeScriptRustPHP

Python

Java

C++

Go

TypeScript

Rust

PHP

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Map and Sum Technique

Time Complexity: O(N + kM), where N is the length of the string and M is the number of digits in the transformed number.
Space Complexity: O(M), as we store the transformed number as a string.

Direct Digit Sum Accumulation

Time Complexity: O(N + k*logM), where M is the intermediate sum value.
Space Complexity: O(1).

Simulation—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Map and Sum TechniqueO(n + k * d)O(n)When implementing the problem exactly as described or when learning basic string-to-number transformations.
Direct Digit Sum AccumulationO(n + k)O(1)Best for interviews and production code where avoiding extra string storage improves efficiency.

Video Solution

1945. Sum of Digits of String After Convert | math | strings | Leetcode Daily Challenge • ShashCode • 3,275 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Sum of Digits of String After Convert easy or hard?
Sum of Digits of String After Convert is classified as an Easy problem on LeetCode with a high acceptance rate of around 75%. It mainly tests string traversal, digit manipulation, and simple simulation logic rather than advanced data structures or algorithms.
Sum of Digits of String After Convert Python/Java solution
The solution in Python or Java typically iterates through the string, converts characters using ASCII arithmetic (c - 'a' + 1), and accumulates digit sums. After computing the initial sum, a loop runs k − 1 times to repeatedly sum the digits of the current number.
How to solve Sum of Digits of String After Convert in O(n)?
Convert each character to its alphabet position and immediately add the digits of that number to a running total. This effectively performs the first transformation without building a string. Then repeat the digit-sum operation on the resulting number for the remaining k − 1 iterations.
What is the best approach for Sum of Digits of String After Convert?
Direct Digit Sum Accumulation is the best approach. Instead of building the full numeric string after converting characters, you immediately add the digits of each character’s alphabet value. This reduces memory usage and keeps the complexity at O(n + k) time with O(1) space.
Is Sum of Digits of String After Convert asked at Google/Amazon/Meta?
This problem is categorized as an easy string and simulation problem on LeetCode and is commonly used in early interview rounds or coding assessments. Companies like Amazon and other tech firms often include similar string transformation or digit manipulation questions to test basic algorithmic thinking.
What data structure is used in Sum of Digits of String After Convert?
No complex data structure is required. The problem mainly uses string traversal and integer arithmetic. The optimized solution relies on simple digit processing and a running sum variable, making it a simulation-style problem.
What is the time complexity of Sum of Digits of String After Convert?
The optimal solution runs in O(n + k) time, where n is the length of the input string and k is the number of digit-sum transformations. The string is processed once for character conversion, and each remaining transformation operates on a small integer with only a few digits.

Ready to solve this problem?

Practice Sum of Digits of String After Convert with our built-in code editor and test cases.

Practice on FleetCode
Previous

Add Digits

Next

Count Integers With Even Digit Sum