#1844

Easy

auto_awesomeString-driven solution strategy

LeetCode Problem Workspace

Replace All Digits with Characters

Transform a string by replacing digits at odd indices using the preceding character with a shift operation for accurate results.

string

Problem Statement

You are given a 0-indexed string s where letters appear at even indices and digits appear at odd indices. Each digit represents a shift to apply to the previous letter in the string. Implement a transformation that replaces every digit with the corresponding shifted character.

Define a shift operation shift(c, x) which returns the xth character after character c in the alphabet. For each odd index i, replace s[i] with shift(s[i-1], s[i]). Return the fully transformed string after all replacements.

Examples

Example 1

Input: s = "a1c1e1"

Output: "abcdef"

The digits are replaced as follows:

s[1] -> shift('a',1) = 'b'
s[3] -> shift('c',1) = 'd'
s[5] -> shift('e',1) = 'f'

Example 2

Input: s = "a1b2c3d4e"

Output: "abbdcfdhe"

The digits are replaced as follows:

s[1] -> shift('a',1) = 'b'
s[3] -> shift('b',2) = 'd'
s[5] -> shift('c',3) = 'f'
s[7] -> shift('d',4) = 'h'

Constraints

1 <= s.length <= 100
s consists only of lowercase English letters and digits.
shift(s[i-1], s[i]) <= 'z' for all odd indices i.

Solution Approach

Iterate and Replace

Loop through the string using the index, check if the current index is odd, and if so, replace the digit with shift(previous character, digit). This ensures direct application of the string-driven solution strategy.

Use ASCII Arithmetic

Convert characters to ASCII codes to perform shifts, then convert back to characters. This avoids building complex mappings and guarantees correctness for each character replacement.

Build Result Efficiently

Construct the final string by appending each character after processing. This avoids in-place mutation issues and preserves linear time and space efficiency while handling each shift precisely.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity is O(n) since each character is visited once and each shift operation is O(1). Space complexity is O(n) for constructing the new string with replaced characters.

What Interviewers Usually Probe

Ask candidate to clarify how shift(c, x) works for letters and digits.
Check if the solution handles strings of maximum allowed length up to 100 characters.
Listen for reasoning about sequential processing versus precomputing shifts.

Common Pitfalls or Variants

Common pitfalls

Misaligning indices and applying shifts to even indices instead of odd ones.
Failing to convert digit characters to integer values before applying the shift.
Modifying the original string in place and encountering unexpected results due to immutability.

Follow-up variants

Strings where digits may represent negative shifts or wrap-around alphabet positions.
Input strings containing only letters, testing edge behavior when no shifts are required.
Use of a different base alphabet or Unicode characters for shift operations.

FAQ

What is the main idea behind Replace All Digits with Characters?

The main idea is to sequentially replace digits at odd indices with letters obtained by shifting the previous character by the digit's numeric value.

How do I implement the shift operation safely?

Convert the previous character to its ASCII code, add the digit value, then convert back to a character to get the shifted letter.

Can this approach handle the maximum string length efficiently?

Yes, because each character is processed once, giving O(n) time complexity and O(n) space for the result string.

What is a common mistake when replacing digits in this problem?

A common mistake is forgetting to convert digit characters to integers before applying the shift, leading to incorrect replacements.

Does this solution pattern apply to other string transformation problems?

Yes, this string-driven solution strategy is useful whenever transformations depend on neighboring character values and sequential replacement rules.

terminal

Solution

Solution 1: Simulation

Traverse the string, for characters at odd indices, replace them with the character that is a certain number of positions after the previous character.

1

2

3

4

5

6

class Solution:
    def replaceDigits(self, s: str) -> str:
        s = list(s)
        for i in range(1, len(s), 2):
            s[i] = chr(ord(s[i - 1]) + int(s[i]))
        return ''.join(s)

Continue Practicing

#1839 longest substring of all vowels in order #1849 splitting a string into descending consecutive values #1850 minimum adjacent swaps to reach the kth smallest number