Partition String - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Start Building

Begin with the first character and check if it's been seen before

Extend or Commit

If unique, save it as a segment. If seen, add another character

Track History

Use hash set to remember all previous segments

Repeat Process

Continue until the entire string is partitioned

Key Takeaway

🎯 Key Insight: By using a hash set to track seen segments and greedily choosing the shortest unique segment at each step, we can efficiently partition any string while maintaining uniqueness with optimal time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We visit each character once O(n), but string operations and hashing can take O(n) in worst case, giving O(n²) overall

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores at most O(n) unique segments, each taking O(n) space in worst case

⚡ Linearithmic Space

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

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

Approach	Time	Space	Notes
✓ Brute Force (Generate All Partitions)	O(2^n)	O(n)	Generate all possible partitions and find the first valid one
One-Pass Hash Set (Optimal)	O(n²)	O(n)	Use hash set to track seen segments while building partitions greedily

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

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Partitions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler