Encode and Decode Strings - Practice Coding Problems

Encode and Decode Strings - Problem

Design an algorithm to encode and decode strings for network transmission.

You need to implement two functions that work together:

🔐 encode(strs): Takes a list of strings and converts them into a single encoded string
🔓 decode(s): Takes the encoded string and reconstructs the original list of strings

The challenge is that strings can contain any characters including delimiters you might think to use! For example, if you use comma as a separator, what happens when a string contains commas?

Example:
Input: ["hello", "world"]
encode(strs) → "5#hello5#world"
decode("5#hello5#world") → ["hello", "world"]

Your solution must handle edge cases like empty strings, strings with special characters, and even strings that look like your encoding format!

Input & Output

example_1.py — Basic Strings

$ Input: ["hello", "world"]

› Output: Encoded: "5#hello5#world", Decoded: ["hello", "world"]

💡 Note: Each string is prefixed with its length and a delimiter. 'hello' has 5 characters, so it becomes '5#hello'. The decoder reads '5', then takes exactly 5 characters after '#'.

example_2.py — Empty Strings

$ Input: ["", "a", ""]

› Output: Encoded: "0#1#a0#", Decoded: ["", "a", ""]

💡 Note: Empty strings have length 0, so they become '0#' (length 0, delimiter, then 0 characters). This handles empty strings correctly.

example_3.py — Strings with Special Characters

$ Input: ["a#b", "c#d", "4#abc"]

› Output: Encoded: "3#a#b3#c#d5#4#abc", Decoded: ["a#b", "c#d", "4#abc"]

💡 Note: Even when strings contain '#' or look like encoded format, the length-prefix approach works correctly because we read exactly the specified number of characters.

Constraints

0 ≤ strs.length ≤ 200
0 ≤ strs[i].length ≤ 200
strs[i] contains any possible characters out of 256 valid ASCII characters
The encoded string must be decodable back to the original list
No built-in serialization methods allowed (like eval, JSON.parse, etc.)

Visualization

Tap to expand

Understanding the Visualization

Label each package

Write the size of each string followed by '#' as a separator

Pack everything together

Concatenate all labeled strings into one encoded string

Unpack by reading labels

Read the size, then take exactly that many characters

Key Takeaway

🎯 Key Insight: Length-prefix encoding eliminates ambiguity by telling us exactly how many characters to read, making any delimiter characters within the data safe to handle.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 U Uber 22

The length-prefix encoding approach is optimal, using format 'length#content' for each string. This handles any characters including delimiters by reading exactly the specified number of characters. Time complexity: O(n), Space: O(n) where n is total string length.

Common Approaches

Approach	Time	Space	Notes
✓ Length-Prefix Encoding (Optimal)	O(n)	O(n)	Encode each string as 'length#content' format for reliable encoding/decoding

Length-Prefix Encoding (Optimal) — Algorithm Steps

For encoding: For each string, write its length + '#' + the string itself
Concatenate all encoded strings together
For decoding: Read length until '#', then read exactly that many characters
Repeat until the entire string is processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Encode with length prefix

Each string becomes 'length#content'

Concatenate encoded strings

Join all encoded parts together

Decode by reading lengths

Read length, then exactly that many characters

Code -

solution.c — C

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

char* encode(char** strs, int strsSize) {
    if (strsSize == 0) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Calculate total size needed
    int totalSize = 0;
    for (int i = 0; i < strsSize; i++) {
        int len = strlen(strs[i]);
        totalSize += snprintf(NULL, 0, "%d", len) + 1 + len; // digits + '#' + string
    }
    
    char* result = malloc(totalSize + 1);
    result[0] = '\0';
    
    for (int i = 0; i < strsSize; i++) {
        int len = strlen(strs[i]);
        char buffer[20];
        sprintf(buffer, "%d#", len);
        strcat(result, buffer);
        strcat(result, strs[i]);
    }
    return result;
}

char** decode(char* s, int* returnSize) {
    char** result = malloc(1000 * sizeof(char*)); // Assume max 1000 strings
    *returnSize = 0;
    
    int i = 0;
    int len = strlen(s);
    
    while (i < len) {
        // Find delimiter '#'
        int delimiterPos = i;
        while (delimiterPos < len && s[delimiterPos] != '#') {
            delimiterPos++;
        }
        
        // Extract length
        char lengthStr[20];
        strncpy(lengthStr, s + i, delimiterPos - i);
        lengthStr[delimiterPos - i] = '\0';
        int strLen = atoi(lengthStr);
        
        // Extract string
        int start = delimiterPos + 1;
        result[*returnSize] = malloc(strLen + 1);
        strncpy(result[*returnSize], s + start, strLen);
        result[*returnSize][strLen] = '\0';
        (*returnSize)++;
        
        i = start + strLen;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time where n is the total length of all strings - we process each character once

✓ Linear Growth

Space Complexity

O(n)

Space for encoded string and decoded result, proportional to input size

⚡ Linearithmic Space

67.8K Views

High Frequency

~25 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

Length-Prefix Encoding (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler