Decode String - Practice Coding Problems

Decode String - Problem

Imagine you're working with a compressed text format where repeated patterns are encoded in a special way. Given an encoded string, your task is to decode it and return the original expanded string.

The encoding follows this simple rule: k[encoded_string], where the encoded_string inside the square brackets should be repeated exactly k times. The number k is guaranteed to be a positive integer.

Key Points:

The input string is always valid with well-formed brackets
No extra whitespaces exist
Original data contains no digits (digits are only for repeat counts)
Patterns can be nested: 2[a3[bc]] means repeat a3[bc] twice
Output length will never exceed 10⁵

Examples:

"3[a]" → "aaa"
"2[bc]" → "bcbc"
"3[a2[c]]" → "accaccacc"

Input & Output

example_1.py — Simple Repetition

$ Input: s = "3[a]"

› Output: "aaa"

💡 Note: The letter 'a' should be repeated 3 times, resulting in "aaa".

example_2.py — Nested Pattern

$ Input: s = "2[bc]"

› Output: "bcbc"

💡 Note: The string "bc" should be repeated 2 times, resulting in "bcbc".

example_3.py — Complex Nesting

$ Input: s = "3[a2[c]]"

› Output: "accaccacc"

💡 Note: First, "2[c]" becomes "cc". Then "3[acc]" becomes "accaccacc".

Visualization

Tap to expand

Understanding the Visualization

Identify Structure

Parse the string to identify nested bracket patterns, like layers of an onion

Handle Nesting

Use recursion or stack to manage the nested structure - process inner patterns first

Expand & Combine

Multiply inner results by their repeat counts and combine with outer context

Build Final Result

Continue until all patterns are expanded and merged into the final decoded string

Key Takeaway

🎯 Key Insight: The problem is essentially about parsing nested structures - use recursion or a stack to handle the nesting elegantly, processing from innermost to outermost patterns.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is processed exactly once during the recursion

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d where d is the maximum nesting level

✓ Linear Space

Constraints

1 ≤ s.length ≤ 30
s consists of lowercase English letters, digits, and square brackets '[]'
s is guaranteed to be a valid input
All the integers in s are in the range [1, 300]
The length of the output will never exceed 10⁵

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 25

The optimal approach uses recursion with index tracking to elegantly handle nested patterns. By maintaining a global index and making recursive calls when '[' is encountered, we naturally parse the string structure. The recursive solution achieves O(n) time complexity with O(d) space where d is the nesting depth, making it both efficient and highly readable.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Solution (Optimal)	O(n)	O(d)	Use recursion with index tracking to parse nested patterns elegantly
Stack-based Iterative Approach	O(n)	O(n)	Use two stacks to track numbers and strings, processing characters one by one
Recursive String Replacement	O(n²)	O(n)	Find innermost brackets and expand them repeatedly until no brackets remain

Recursive Solution (Optimal) — Algorithm Steps

Use a global index to track current position in string
Parse digits to get the repeat count k
When '[' is found, recursively decode the inner content
When ']' is found, return current result to parent
Repeat the decoded content k times and continue
Handle regular characters by appending to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Number

Read digits to get repeat count

Enter Bracket

When '[' found, make recursive call

Build Result

Process inner content recursively

Return & Repeat

Return result and repeat k times

Code -

solution.c — C

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

static int index_global = 0;

char* decode(const char* s) {
    char* result = (char*)malloc(10000 * sizeof(char));
    result[0] = '\0';
    int num = 0;
    
    while (index_global < strlen(s)) {
        char c = s[index_global++];
        
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        } else if (c == '[') {
            // Recursively decode inner content
            char* inner = decode(s);
            for (int i = 0; i < num; i++) {
                strcat(result, inner);
            }
            free(inner);
            num = 0;
        } else if (c == ']') {
            // End of current level
            return result;
        } else {
            // Regular character
            int len = strlen(result);
            result[len] = c;
            result[len + 1] = '\0';
        }
    }
    
    return result;
}

char* decodeString(char* s) {
    index_global = 0;
    return decode(s);
}

int main() {
    char s[1000];
    scanf("%s", s);
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    char* result = decodeString(s);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is processed exactly once during the recursion

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d where d is the maximum nesting level

✓ Linear Space

Constraints

1 ≤ s.length ≤ 30
s consists of lowercase English letters, digits, and square brackets '[]'
s is guaranteed to be a valid input
All the integers in s are in the range [1, 300]
The length of the output will never exceed 10⁵

142.4K Views

High Frequency

~25 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Recursive Solution (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler