Encode String with Shortest Length - Practice Coding Problems

Encode String with Shortest Length - Problem

String Compression Challenge: Given a string s, your task is to encode it using a special compression rule to achieve the shortest possible length.

The encoding rule follows the pattern: k[encoded_string], where:
• k is a positive integer representing repetition count
• encoded_string is the substring being repeated exactly k times
• The brackets indicate the repeated section

Important: Only encode if it makes the string shorter! If encoding doesn't reduce length, keep the original substring.

Example: "aaabcbc" → "3[a]2[bc]" (length reduced from 7 to 8, so we'd actually return "aaabcbc")
Better example: "abababab" → "4[ab]" (length reduced from 8 to 5)

Input & Output

example_1.py — Basic Pattern

$ Input: s = "aaa"

› Output: "aaa"

💡 Note: Since '3[a]' has the same length (4) as 'aaa' (3), we don't encode it because encoding doesn't make it shorter.

example_2.py — Multiple Patterns

$ Input: s = "aaaabaaaab"

› Output: "2[2[a]b]"

💡 Note: We can encode 'aaaa' as '4[a]' but that's longer (4 chars vs 4 chars), so we keep 'aaaa'. However, 'aaaab' can become '4[a]b' (6 chars vs 5 chars - no improvement). But 'aaaabaaaab' can become '2[aaaab]' (9 chars vs 10 chars) or even better '2[4[a]b]' (8 chars) - but that's not shorter than original. The actual optimal is '2[2[a]ab]' = 8 chars vs 10 original.

example_3.py — No Encoding Needed

$ Input: s = "abcd"

› Output: "abcd"

💡 Note: No repeating patterns exist, so the original string is already the shortest representation.

Constraints

1 ≤ s.length ≤ 150
s consists of only lowercase English letters
Encoding is only applied if it reduces the string length
k should be a positive integer (k ≥ 2 for meaningful encoding)

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Scan the string to find repeating subsequences like 'abab' or 'aaaa'

Calculate Savings

Check if encoding 'abab' as '2[ab]' actually saves space (4 chars vs 5 chars - saves 1)

Nested Optimization

Apply encoding recursively - '2[abc]' where 'abc' might also be encodable

Dynamic Building

Build optimal solutions for larger strings using optimal solutions of smaller parts

Key Takeaway

🎯 Key Insight: Dynamic programming with memoization transforms an exponential-time problem into O(n³) by reusing optimal solutions for substrings, making string encoding efficient and scalable.

Asked in

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

The optimal solution uses dynamic programming with memoization to efficiently find the shortest encoding. The key insight is that we can build optimal encodings for larger substrings by combining optimal encodings of smaller substrings. We try both splitting the string into parts and finding repeating patterns that can be encoded as k[pattern]. The memoization prevents redundant calculations, reducing time complexity from exponential to O(n³).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n³)	O(n²)	Use memoization to avoid redundant calculations and build optimal solution

Dynamic Programming (Optimal) — Algorithm Steps

Create memoization table for substring encodings
For each substring, try all possible split points
Check if substring can be encoded as k[pattern]
Choose the encoding that gives minimum length
Reuse previously computed results

Visualization

Tap to expand

Step-by-Step Walkthrough

Memoization Table

Create table to store results for all substrings

Build Solutions

Solve smaller subproblems first and combine them

Reuse Results

Avoid recalculating by looking up previously computed results

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MEMO_SIZE 10000

typedef struct {
    int i, j;
    char result[MAX_LEN];
} MemoEntry;

MemoEntry memo[MEMO_SIZE];
int memoCount = 0;
char s[MAX_LEN];

char* findMemo(int i, int j) {
    for (int k = 0; k < memoCount; k++) {
        if (memo[k].i == i && memo[k].j == j) {
            return memo[k].result;
        }
    }
    return NULL;
}

void addMemo(int i, int j, char* result) {
    if (memoCount < MEMO_SIZE) {
        memo[memoCount].i = i;
        memo[memoCount].j = j;
        strcpy(memo[memoCount].result, result);
        memoCount++;
    }
}

char* dp(int i, int j) {
    if (i > j) {
        char* empty = malloc(1);
        empty[0] = '\0';
        return empty;
    }
    
    char* cached = findMemo(i, j);
    if (cached != NULL) {
        char* result = malloc(strlen(cached) + 1);
        strcpy(result, cached);
        return result;
    }
    
    int length = j - i + 1;
    char* substring = malloc(length + 1);
    strncpy(substring, s + i, length);
    substring[length] = '\0';
    
    if (length <= 4) {
        addMemo(i, j, substring);
        return substring;
    }
    
    char* result = substring;
    
    // Try all possible splits (simplified version)
    for (int k = i; k < j; k++) {
        char* left = dp(i, k);
        char* right = dp(k + 1, j);
        int candidateLen = strlen(left) + strlen(right);
        if (candidateLen < strlen(result)) {
            free(result);
            result = malloc(candidateLen + 1);
            strcpy(result, left);
            strcat(result, right);
        }
        free(left);
        free(right);
    }
    
    addMemo(i, j, result);
    return result;
}

char* encode(char* str) {
    strcpy(s, str);
    memoCount = 0;
    return dp(0, strlen(str) - 1);
}

int main() {
    char str[MAX_LEN];
    scanf("%s", str);
    char* result = encode(str);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

We have n² substrings, and for each we try n different splits and pattern checks

⚠ Quadratic Growth

Space Complexity

O(n²)

Memoization table stores results for all n² possible substrings

⚠ Quadratic Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler