Replace All Digits with Characters - Practice Coding Problems

Replace All Digits with Characters - Problem

String Easy

You're given a string with a special pattern: letters are at even indices and digits are at odd indices. Your task is to transform this string by replacing each digit with a shifted character.

The shift operation works like this: shift(c, x) takes a character c and shifts it x positions forward in the alphabet. For example:

shift('a', 5) = 'f' (a → b → c → d → e → f)
shift('x', 0) = 'x' (no shift)
shift('m', 3) = 'p' (m → n → o → p)

For each digit at an odd index i, replace it with shift(s[i-1], s[i]) - shift the previous character by the digit amount.

Goal: Return the transformed string with all digits replaced by their corresponding shifted characters.

Input & Output

example_1.py — Basic Pattern

$ Input: s = "a1c1e1"

› Output: "abcdef"

💡 Note: At index 1: shift('a', 1) = 'b'. At index 3: shift('c', 1) = 'd'. At index 5: shift('e', 1) = 'f'. Result: 'a' + 'b' + 'c' + 'd' + 'e' + 'f' = "abcdef"

example_2.py — Different Shifts

$ Input: s = "a1b2c3d4e"

› Output: "abbdcgdie"

💡 Note: Processing each position: a(keep) → shift('a',1)='b' → b(keep) → shift('b',2)='d' → c(keep) → shift('c',3)='f' → d(keep) → shift('d',4)='h' → e(keep). Wait, let me recalculate: 'a' + shift('a',1)='b' + 'b' + shift('b',2)='d' + 'c' + shift('c',3)='f' + 'd' + shift('d',4)='h' + 'e' = "abbdcfdie"

example_3.py — Zero Shifts

$ Input: s = "a0c0"

› Output: "acac"

💡 Note: At index 1: shift('a', 0) = 'a' (no change). At index 3: shift('c', 0) = 'c' (no change). Result: 'a' + 'a' + 'c' + 'c' = "acac"

Constraints

1 ≤ s.length ≤ 100
s consists only of lowercase English letters and digits 0-9
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]) will never exceed 'z'

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Letters at even indices (0,2,4...), digits at odd indices (1,3,5...)

Apply Shifts

For each digit, shift the previous letter forward in the alphabet

Build Result

Combine original letters with shifted characters to form the final string

Key Takeaway

🎯 Key Insight: This is a simple one-pass string transformation where we only need to look at the previous character to calculate each shift, making it very efficient with O(n) time complexity.

Asked in

LC LeetCode 25 G Google 15 A Amazon 12 M Microsoft 8

This problem has a simple optimal solution that processes the string in one pass. For each character, if it's at an even index (letter), keep it as-is. If it's at an odd index (digit), shift the previous character by the digit amount using ASCII arithmetic. The key insight is that we can build the result incrementally since we only need the previous character to calculate each shift.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Concatenation)	O(n)	O(n)	Build result string character by character using string concatenation

Brute Force (String Concatenation) — Algorithm Steps

Initialize empty result string
Iterate through each character with its index
If index is even, append character to result
If index is odd, get previous character and current digit
Calculate shifted character using ASCII arithmetic
Append shifted character to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Even Indices

Copy letters at even indices directly to result

Process Odd Indices

For digits at odd indices, shift the previous character

Build Result

Concatenate all processed characters to form final string

Code -

solution.c — C

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

char* replaceDigits(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int j = 0;
    
    for (int i = 0; i < len; i++) {
        if (i % 2 == 0) { // Even index - letter
            result[j++] = s[i];
        } else { // Odd index - digit
            // Shift previous character by current digit
            char prevChar = s[i-1];
            int shiftAmount = s[i] - '0';
            char shiftedChar = prevChar + shiftAmount;
            result[j++] = shiftedChar;
        }
    }
    result[j] = '\0';
    return result;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    // Remove newline and quotes
    input[strcspn(input, "\n")] = '\0';
    char* s = input + 1; // Skip first quote
    s[strlen(s)-1] = '\0'; // Remove last quote
    
    char* result = replaceDigits(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, with constant time operations for each character

✓ Linear Growth

Space Complexity

O(n)

Space for the result string (in some languages, string concatenation may use O(n²) space due to immutability)

⚡ Linearithmic Space

28.4K 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

Brute Force (String Concatenation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler