Replace All Digits with Characters

Replace All Digits with Characters - Problem

String Easy

You are given a 0-indexed string s that has lowercase English letters in its even indices and digits in its odd indices.

You must perform an operation shift(c, x), where c is a character and x is a digit, that returns the xth character after c.

For example, shift('a', 5) = 'f' and shift('x', 0) = 'x'.

For every odd index i, you want to replace the digit s[i] with the result of the shift(s[i-1], s[i]) operation.

Return s after replacing all digits. It is guaranteed that shift(s[i-1], s[i]) will never exceed 'z'.

Note that shift(c, x) is not a preloaded function, but an operation to be implemented as part of the solution.

Input & Output

Example 1 — Basic Case

$ Input: s = "a1c1e1"

› Output: "abcdef"

💡 Note: Digits at indices 1, 3, 5: '1' shifts 'a'→'b', '1' shifts 'c'→'d', '1' shifts 'e'→'f'. Result: a + b + c + d + e + f = "abcdef"

Example 2 — Different Shifts

$ Input: s = "a1b2c3"

› Output: "abbdcf"

💡 Note: Index 1: 'a' + 1 = 'b', Index 3: 'b' + 2 = 'd', Index 5: 'c' + 3 = 'f'. Result: a + b + b + d + c + f = "abbdcf"

Example 3 — Zero Shift

$ Input: s = "a0c0e0"

› Output: "acacee"

💡 Note: Zero shift means same character: 'a' + 0 = 'a', 'c' + 0 = 'c', 'e' + 0 = 'e'

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters and digits
s[i] is a lowercase English letter if i is even
s[i] is a digit if i is odd
shift(s[i-1], s[i]) ≤ 'z' for all odd indices i

Visualization

Tap to expand

Asked in

a Amazon 15 f Facebook 12

The key insight is using ASCII arithmetic to shift characters. For each digit at odd index, shift the previous character by the digit amount using chr(ord(char) + digit). Best approach processes the string in one pass. Time: O(n), Space: O(n)

Common Approaches

✓ Character-by-Character Processing

⏱️ Time: O(n) Space: O(n)

Process each character in the string. When we encounter a digit at an odd index, convert it to integer and shift the previous character by that amount using ASCII arithmetic.

In-Place String Building

⏱️ Time: O(n) Space: O(n)

Instead of converting to character array, build the result string directly by concatenating characters and shifted results. This approach is more memory efficient in some languages.

Character-by-Character Processing — Algorithm Steps

Step 1: Convert string to character array for modification
Step 2: Iterate through odd indices (1, 3, 5, ...)
Step 3: For each digit, shift the previous character and replace the digit
Step 4: Convert back to string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Input String

Letters at even indices, digits at odd indices

Shift Operation

For each digit, shift previous letter by digit amount

Result

All digits replaced with shifted characters

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char* result = malloc((len + 1) * sizeof(char));
    strcpy(result, s);
    
    for (int i = 1; i < len; i += 2) {
        int digit = result[i] - '0';
        char prevChar = result[i-1];
        char shiftedChar = prevChar + digit;
        result[i] = shiftedChar;
    }
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, visiting each character once

✓ Linear Growth

Space Complexity

O(n)

Character array to store the modified string

⚡ Linearithmic Space

34.0K Views

Medium Frequency

~8 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

Character-by-Character Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler