Decoded String at Index

Decoded String at Index - Problem

String Stack Medium

You are given an encoded string s. To decode the string to a tape, the encoded string is read one character at a time and the following steps are taken:

If the character read is a letter, that letter is written onto the tape.
If the character read is a digit d, the entire current tape is repeatedly written d - 1 more times in total.

Given an integer k, return the k-th letter (1-indexed) in the decoded string.

Input & Output

Example 1 — Basic Case

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

› Output: "o"

💡 Note: The decoded string is "leetleetcodeleetleetcodeleetleetcode". The 10th letter is "o".

Example 2 — Simple Multiplication

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

› Output: "h"

💡 Note: The decoded string is "hahahaha". The 5th letter is "h".

Example 3 — Single Character

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

› Output: "a"

💡 Note: The decoded string starts with "a", so the 1st letter is "a".

Constraints

2 ≤ s.length ≤ 100
s consists of lowercase English letters and digits 2-9
s starts with a letter
1 ≤ k ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to work backwards instead of building the entire decoded string. Calculate the total size first, then work backwards from position k using modulo arithmetic to find the target character without building the massive string. Best approach is reverse calculation with Time: O(N), Space: O(1).

Common Approaches

✓ Brute Force - Build Full String

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

Iterate through each character in the encoded string. For letters, append to result. For digits, repeat the current string that many times. Finally return the k-th character.

Reverse Calculation

⏱️ Time: O(N) Space: O(1)

First pass calculates the final decoded string length. Second pass works backwards from position k, reducing the problem size at each step until we find the actual character.

Brute Force - Build Full String — Algorithm Steps

Initialize empty result string
For each character in encoded string
If letter: append to result
If digit: repeat current result d times
Return k-th character from result

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Letters

Add each letter to result string

Process Digits

Repeat entire current string d times

Return Character

Return the k-th character from final string

Code -

solution.c — C

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

char* solution(char* s, int k) {
    char* result = (char*)malloc(1000000 * sizeof(char));
    result[0] = '\0';
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        if (isalpha(s[i])) {
            int resLen = strlen(result);
            result[resLen] = s[i];
            result[resLen + 1] = '\0';
        } else {
            int digit = s[i] - '0';
            char* temp = (char*)malloc(strlen(result) + 1);
            strcpy(temp, result);
            result[0] = '\0';
            for (int j = 0; j < digit; j++) {
                strcat(result, temp);
            }
            free(temp);
        }
        // Early termination to avoid memory issues
        if (strlen(result) >= k) {
            char* answer = (char*)malloc(2);
            answer[0] = result[k-1];
            answer[1] = '\0';
            free(result);
            return answer;
        }
    }
    
    char* answer = (char*)malloc(2);
    if (strlen(result) >= k) {
        answer[0] = result[k-1];
        answer[1] = '\0';
    } else {
        answer[0] = '\0';
    }
    free(result);
    return answer;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(N)

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

✓ Linear Growth

Space Complexity

O(N)

Store the entire decoded string which can be exponentially large

✓ Linear Space

125.0K Views

Medium Frequency

~25 min Avg. Time

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