Split Message Based on Limit - Practice Coding Problems

Split Message Based on Limit - Problem

Message Pagination Problem: You need to split a message into multiple parts where each part includes pagination information in the format <a/b>.

Given a message string and a positive integer limit, you must:

Split the message into one or more parts
Each part must have suffix <a/b> where b is total parts and a is the current part number (1-indexed)
Each part's total length (including suffix) must be exactly limit, except the last part which can be ≤ limit
When suffixes are removed and parts concatenated, they should equal the original message
Minimize the total number of parts

Return the array of paginated parts, or an empty array if impossible.

Input & Output

example_1.py — Basic Split

$ Input: message = "this is really a very awesome message", limit = 9

› Output: ["thi<1/14>", "s i<2/14>", "s r<3/14>", "eal<4/14>", "ly <5/14>", "a v<6/14>", "ery<7/14>", " aw<8/14>", "eso<9/14>", "me<10/14>", " m<11/14>", "ess<12/14>", "ag<13/14>", "e<14/14>"]

💡 Note: With limit=9, each part can hold at most 9 characters including the suffix. The suffix "<10/14>" takes 7 chars, leaving 2 chars for content in parts 10-14. The algorithm finds that 14 parts is the minimum needed.

example_2.py — Impossible Case

$ Input: message = "short message", limit = 15

› Output: []

💡 Note: Even with 1 part, "short message<1/1>" would be 19 characters, exceeding the limit of 15. Since it's impossible to fit the message with any number of parts, return empty array.

example_3.py — Single Part

$ Input: message = "hello", limit = 12

› Output: ["hello<1/1>"]

💡 Note: The entire message "hello" plus suffix "<1/1>" equals "hello<1/1>" with length 10, which fits within limit 12. Only one part is needed.

Visualization

Tap to expand

Understanding the Visualization

Calculate Space

For each candidate part count, calculate how much space suffixes will take

Check Feasibility

Verify if remaining space can accommodate the entire message

Binary Search

Use binary search to efficiently find the minimum feasible part count

Generate Result

Split the message using the optimal part count

Key Takeaway

🎯 Key Insight: Binary search works because if we can split into k parts, we can usually split into k+1 parts too (monotonic property). The challenge is calculating space efficiently for each candidate part count.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try up to n different part counts, and for each we simulate the splitting process which takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the result array and temporary calculations

⚡ Linearithmic Space

Constraints

1 ≤ message.length ≤ 10⁴
1 ≤ limit ≤ 10⁴
message consists only of lowercase English letters and spaces
1 ≤ limit ≤ 10⁴

Asked in

G Google 32 f Meta 28 a Amazon 21 ⊞ Microsoft 15

The optimal approach uses binary search to find the minimum number of parts needed. The key insight is that if we can split a message into k parts, we can usually split it into more parts too, giving us a monotonic property perfect for binary search. We search for the minimum k where the total available space (after reserving space for all suffixes) is enough for the entire message.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Enumeration	O(n²)	O(n)	Try every possible number of parts from 1 to message length
Binary Search Optimization	O(n log n)	O(n)	Use binary search to efficiently find the minimum number of parts needed

Brute Force Enumeration — Algorithm Steps

Try parts = 1, 2, 3, ... up to message.length
For each parts count, calculate suffix lengths '<i/parts>'
Calculate available space per part for actual message content
Simulate the splitting process to verify feasibility
Return the first valid split found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try 1 Part

Check if entire message fits with suffix <1/1>

Try 2 Parts

Check if message fits split with suffixes <1/2>, <2/2>

Try 3 Parts

Continue until finding valid split

Code -

solution.c — C

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

char** splitMessage(char* message, int limit, int* returnSize) {
    int n = strlen(message);
    *returnSize = 0;
    
    // Try different numbers of parts
    for (int parts = 1; parts <= n; parts++) {
        if (canSplit(message, limit, parts)) {
            return doSplit(message, limit, parts, returnSize);
        }
    }
    
    return NULL;
}

int canSplit(char* message, int limit, int parts) {
    // Calculate total suffix space needed
    int totalSuffixSpace = 0;
    for (int i = 1; i <= parts; i++) {
        char suffix[50];
        sprintf(suffix, "<%d/%d>", i, parts);
        if (strlen(suffix) >= limit) {
            return 0;
        }
        totalSuffixSpace += strlen(suffix);
    }
    
    // Check if message fits in remaining space
    int totalAvailable = parts * limit - totalSuffixSpace;
    return totalAvailable >= strlen(message);
}

char** doSplit(char* message, int limit, int parts, int* returnSize) {
    char** result = (char**)malloc(parts * sizeof(char*));
    int pos = 0;
    *returnSize = parts;
    
    for (int i = 1; i <= parts; i++) {
        char suffix[50];
        sprintf(suffix, "<%d/%d>", i, parts);
        int available = limit - strlen(suffix);
        
        result[i-1] = (char*)malloc((limit + 1) * sizeof(char));
        
        if (i == parts) {
            // Last part can take remaining message
            strcpy(result[i-1], message + pos);
            strcat(result[i-1], suffix);
        } else {
            strncpy(result[i-1], message + pos, available);
            result[i-1][available] = '\0';
            strcat(result[i-1], suffix);
            pos += available;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try up to n different part counts, and for each we simulate the splitting process which takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to store the result array and temporary calculations

⚡ Linearithmic Space

Constraints

1 ≤ message.length ≤ 10⁴
1 ≤ limit ≤ 10⁴
message consists only of lowercase English letters and spaces
1 ≤ limit ≤ 10⁴

22.1K Views

Medium Frequency

~25 min Avg. Time

847 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

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler