Partition String

Partition String - Problem

You have a string s that you need to partition into unique segments using a greedy approach. The goal is to create the shortest possible segments while ensuring no two segments are identical.

Algorithm:

Start at index 0 and build a segment character by character
Keep extending the current segment until it becomes unique (not seen before)
Once unique, add it to your result and mark it as "seen"
Start a new segment from the next index
Repeat until the entire string is processed

Example: For string "abcabc", we get segments ["a", "b", "c", "ab", "c"] because when we reach the second 'a', we need "ab" to make it unique since "a" was already seen.

Input & Output

example_1.py — Basic Case

$ Input: s = "abcabc"

› Output: ["a", "b", "c", "ab", "c"]

💡 Note: Start with 'a' (unique) → 'b' (unique) → 'c' (unique) → second 'a' is seen, so extend to 'ab' (unique) → final 'c' is seen but we're at the end, so it becomes a separate segment

example_2.py — Repeated Pattern

$ Input: s = "aaaa"

› Output: ["a", "aa", "aaa"]

💡 Note: First 'a' is unique. Second 'a' is seen, but 'aa' is unique. Third 'a' is seen, 'aa' is seen, but 'aaa' is unique. Fourth 'a' continues the pattern.

example_3.py — All Unique Characters

$ Input: s = "abcdef"

› Output: ["a", "b", "c", "d", "e", "f"]

💡 Note: Each character is unique on its own, so each forms its own segment - this is the optimal greedy solution.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
The algorithm must use a greedy approach - always choose the shortest unique segment

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a greedy approach with hash set for O(n²) time complexity. We iterate through the string once, building segments character by character. For each position, we extend the current segment and check if it exists in our hash set. As soon as we find a unique segment, we add it to both our result and hash set, then start building the next segment. This ensures we always get the shortest possible segments while maintaining uniqueness.

Common Approaches

✓ Brute Force (Generate All Partitions)

⏱️ Time: O(2^n) Space: O(n)

This approach generates all possible ways to partition the string and checks each partition to see if all segments are unique. While conceptually simple, it's extremely inefficient due to the exponential number of partitions.

One-Pass Hash Set (Optimal)

⏱️ Time: O(n²) Space: O(n)

This is the optimal greedy approach. We iterate through the string once, building segments character by character. We use a hash set to quickly check if the current segment has been seen before. As soon as we have a unique segment, we add it to our result and start building the next segment.

Brute Force (Generate All Partitions) — Algorithm Steps

Generate all possible partitions of the string
For each partition, check if all segments are unique
Return the first valid partition found
Use backtracking to explore all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Exploration

Begin at index 0, try all possible first segments

Branch Out

For each segment choice, recursively partition the remaining string

Check Validity

When we reach the end, verify all segments are unique

Backtrack

If invalid, backtrack and try different choices

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_SEGMENTS 100

char segments[MAX_SEGMENTS][MAX_LEN];
int segCount = 0;

int isUnique(char segs[][MAX_LEN], int count) {
    for (int i = 0; i < count; i++) {
        for (int j = i + 1; j < count; j++) {
            if (strcmp(segs[i], segs[j]) == 0) {
                return 0;
            }
        }
    }
    return 1;
}

int backtrack(char* s, int start, int len, char result[][MAX_LEN], int* resultCount) {
    if (start == len) {
        if (isUnique(result, *resultCount)) {
            return 1;
        }
        return 0;
    }
    
    for (int end = start + 1; end <= len; end++) {
        strncpy(result[*resultCount], s + start, end - start);
        result[*resultCount][end - start] = '\0';
        (*resultCount)++;
        
        if (backtrack(s, end, len, result, resultCount)) {
            return 1;
        }
        (*resultCount)--;
    }
    return 0;
}

int main() {
    char s[MAX_LEN];
    fgets(s, MAX_LEN, stdin);
    s[strcspn(s, "\n")] = 0;
    
    // Remove quotes
    char* clean = s;
    if (s[0] == '"') clean++;
    int len = strlen(clean);
    if (clean[len-1] == '"') clean[len-1] = '\0', len--;
    
    char result[MAX_SEGMENTS][MAX_LEN];
    int count = 0;
    
    if (backtrack(clean, 0, len, result, &count)) {
        printf("[");
        for (int i = 0; i < count; i++) {
            printf("\"%s\"", result[i]);
            if (i < count - 1) printf(", ");
        }
        printf("]\n");
    } else {
        printf("[]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We have 2^(n-1) possible partitions where n is string length. Each partition takes O(n²) time to validate uniqueness

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and space to store current partition

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~12 min Avg. Time

892 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

Brute Force (Generate All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler