Decode String

Decode String - Problem

Given an encoded string, return its decoded string.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.

You may assume that the input string is always valid; there are no extra white spaces, square brackets are well-formed, etc. Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k.

For example, there will not be input like 3a or 2[4].

The test cases are generated so that the length of the output will never exceed 10⁵.

Input & Output

Example 1 — Nested Brackets

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

› Output: "accaccacc"

💡 Note: First decode inner pattern: 2[c] → "cc", then 3[acc] → "accaccacc"

Example 2 — Sequential Patterns

$ Input: s = "2[bc]3[cd]ef"

› Output: "bcbccdcdcdef"

💡 Note: Decode 2[bc] → "bcbc", then 3[cd] → "cdcdcd", combine with "ef" → "bcbccdcdcdef"

Example 3 — Simple Pattern

$ Input: s = "abc3[cd]xyz"

› Output: "abccdcdcdxyz"

💡 Note: Keep "abc", decode 3[cd] → "cdcdcd", append "xyz" → "abccdcdcdxyz"

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]

Visualization

Tap to expand

Asked in

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

The key insight is to process nested brackets from inside out, either using a stack to track state or recursion to handle nesting naturally. The stack approach is most efficient with O(n) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive with Memoization	O(n)	O(n)	Use recursion to decode nested patterns with memoization to avoid recomputing
Brute Force - String Replacement	O(n²)	O(n²)	Repeatedly find and replace the innermost bracket patterns until none remain
Stack Approach	O(n)	O(n)	Use two stacks to track current string and repeat counts as we traverse the input

Recursive with Memoization — Algorithm Steps

Parse input character by character
When digit found, build the number
When '[' found, recursively decode inner pattern
When ']' found, return current result

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Number

Accumulate digits before '['

Recursive Call

Dive into bracket content

Return & Repeat

Return decoded string and repeat k times

Code -

solution.c — C

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

int index_pos = 0;

char* decode(char* s, char* result) {
    int num = 0;
    int resultLen = 0;
    
    while (index_pos < strlen(s)) {
        char ch = s[index_pos];
        if (isdigit(ch)) {
            num = num * 10 + (ch - '0');
        } else if (ch == '[') {
            index_pos++; // skip '['
            char* decoded = malloc(10001 * sizeof(char));
            decoded[0] = '\0';
            decode(s, decoded);
            for (int i = 0; i < num; i++) {
                strcat(result, decoded);
            }
            free(decoded);
            num = 0;
        } else if (ch == ']') {
            return result;
        } else {
            int len = strlen(result);
            result[len] = ch;
            result[len + 1] = '\0';
        }
        index_pos++;
    }
    
    return result;
}

char* solution(char* s) {
    index_pos = 0;
    char* result = malloc(10001 * sizeof(char));
    result[0] = '\0';
    return decode(s, 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)

Each character processed once, recursion depth limited by nesting

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth plus memoization cache for subproblems

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Recursive with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler