Decoded String at Index - Practice Coding Problems

Decoded String at Index - Problem

String Stack Medium

Imagine you have a magical decoder tape that processes an encoded string character by character to create a much longer decoded string. Here's how the decoding works:

When you encounter a letter, write it directly onto the tape
When you encounter a digit d, repeat the entire current tape content d-1 more times

For example, if the encoded string is "a2bc3":

Start with: ""
Read 'a': tape becomes "a"
Read '2': repeat current tape 1 more time → "aa"
Read 'b': tape becomes "aab"
Read 'c': tape becomes "aabc"
Read '3': repeat current tape 2 more times → "aabcaabcaabc"

Your mission: Given an encoded string s and an integer k, find the k-th character (1-indexed) in the final decoded string without actually building the entire string!

Input & Output

example_1.py — Basic Case

$ Input: s = "leet2code3", k = 10

› Output: "o"

💡 Note: The decoded string is "leetleetcodeleetleetcodeleetleetcode" (length 30). The 10th character (1-indexed) is 'o'.

example_2.py — Simple Multiplication

$ Input: s = "ha22", k = 5

› Output: "h"

💡 Note: Decoding: 'h' → 'ha' → 'haha' → 'hahahahahahahaha'. The 5th character is 'h'.

example_3.py — Single Character

$ Input: s = "a2345678999999999999999", k = 1

› Output: "a"

💡 Note: Even though the final string would be astronomically long, the first character is always 'a'.

Constraints

2 ≤ s.length ≤ 100
s consists only of lowercase English letters and digits 2 through 9
s starts with a letter
1 ≤ k ≤ 10⁹
It is guaranteed that k is less than or equal to the length of the decoded string
Important: The decoded string can be extremely long (exponential growth), but k is guaranteed to be valid

Visualization

Tap to expand

Understanding the Visualization

Calculate Final Size

First pass determines how long the decoded string would be

Reverse the Process

Work backwards, undoing multiplications step by step

Use Modulo Magic

k % current_size tells us which section contains our target

Find the Character

When k becomes 0 and we hit a letter, we found our answer!

Key Takeaway

🎯 Key Insight: Instead of expanding forward (which uses exponential space), we shrink backward using modulo arithmetic to mathematically determine which original character maps to position k.

Asked in

G Google 45 a Amazon 32 f Meta 28 Apple 15

The optimal solution uses a two-pass reverse engineering approach. First, calculate the total decoded length. Then, work backwards through the string, using modulo arithmetic to determine which character at position k corresponds to in the original pattern. This avoids building the exponentially large decoded string entirely, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Build Full String)	O(N)	O(N)	Actually decode the entire string and return the k-th character
Two-Pass Reverse Engineering	O(n)	O(1)	First pass to calculate total length, second pass to work backwards and find the target character

Brute Force (Build Full String) — Algorithm Steps

Initialize an empty result string
Iterate through each character in the encoded string
If it's a letter, append it to the result
If it's a digit d, repeat the current result string d-1 more times
Return the character at position k-1 in the final string

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 'a'

Decoded string: 'a'

Process '2'

Multiply by 2: 'aa'

Process 'b'

Append letter: 'aab'

Process '3'

Multiply by 3: 'aabaabaabaab' (length explodes!)

Code -

solution.c — C

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

char decodeAtIndex(char* s, int k) {
    // WARNING: This approach will fail for large inputs due to memory
    char* decoded = malloc(1000000); // Arbitrary large size
    decoded[0] = '\0';
    int len = 0;
    
    for (int i = 0; s[i]; i++) {
        if (isalpha(s[i])) {
            decoded[len++] = s[i];
            decoded[len] = '\0';
        } else {
            int digit = s[i] - '0';
            int current_len = len;
            for (int j = 1; j < digit; j++) {
                for (int l = 0; l < current_len; l++) {
                    decoded[len++] = decoded[l];
                }
            }
            decoded[len] = '\0';
        }
        
        // Early termination if we have enough characters
        if (len >= k) {
            char result = decoded[k-1];
            free(decoded);
            return result;
        }
    }
    
    char result = (k <= len) ? decoded[k-1] : '\0';
    free(decoded);
    return result;
}

int main() {
    char s[101];
    int k;
    fgets(s, sizeof(s), stdin);
    scanf("%d", &k);
    
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    
    printf("%c\n", decodeAtIndex(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(N)

Where N is the length of the final decoded string, which can be exponentially large

✓ Linear Growth

Space Complexity

O(N)

Need to store the entire decoded string which can be exponentially large

✓ Linear Space

89.2K Views

Medium Frequency

~15 min Avg. Time

1.8K 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 (Build Full String) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler