Partition String - Problem

Given a string s, partition it into unique segments according to the following procedure:

1. Start building a segment beginning at index 0

2. Continue extending the current segment character by character until the current segment has not been seen before

3. Once the segment is unique, add it to your list of segments, mark it as seen, and begin a new segment from the next index

4. Repeat until you reach the end of s

Return an array of strings segments, where segments[i] is the ith segment created.

Input & Output

Example 1 — Basic Partitioning

$ Input: s = "abcabc"

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

💡 Note: Start with "a" (unique), then "b" (unique), then "c" (unique). Next, "a" is seen so extend to "ab" (unique). Finally "c" is seen but we're at end, so add "c".

Example 2 — Repeated Characters

$ Input: s = "ababccc"

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

💡 Note: "a" is unique, "b" is unique, "a" is seen so extend to "ab" (unique), "c" is unique, "c" is seen so extend to "cc" (unique).

Example 3 — Single Character

$ Input: s = "a"

› Output: ["a"]

💡 Note: Only one character, so the entire string "a" forms one unique segment.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a hash set for O(1) lookup of seen segments while building each segment character by character until it's unique. Best approach is Hash Set Optimization with Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force with List Search

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

For each position, extend the current segment character by character. After each extension, search through the entire list of previously seen segments to check if the current segment is unique. Once unique, add it to results and start a new segment.

Hash Set Optimization

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

Build segments incrementally while using a hash set to track previously seen segments. For each position, extend the current segment one character at a time and use the hash set for constant-time lookup to check uniqueness. Once unique, add to results and hash set.

Brute Force with List Search — Algorithm Steps

Start from index 0
Extend current segment one character at a time
Search through all seen segments to check uniqueness
When unique, add to result and mark as seen

Visualization

Tap to expand

Step-by-Step Walkthrough

Extend Segment

Build current segment character by character

Check All Seen

Search through entire seen list for duplicates

Add When Unique

Add segment when no duplicates found

Code -

solution.c — C

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

char** solution(char* s, int* returnSize) {
    int n = strlen(s);
    if (n == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    char** seen = (char**)malloc(n * sizeof(char*));
    char** result = (char**)malloc(n * sizeof(char*));
    int seenCount = 0;
    int resultCount = 0;
    int i = 0;
    
    while (i < n) {
        char* current = (char*)malloc((n + 1) * sizeof(char));
        current[0] = '\0';
        
        // Extend current segment until it's unique or we reach end
        for (int j = i; j < n; j++) {
            int len = strlen(current);
            current[len] = s[j];
            current[len + 1] = '\0';
            
            // Check if current segment is unique
            int isUnique = 1;
            for (int k = 0; k < seenCount; k++) {
                if (strcmp(seen[k], current) == 0) {
                    isUnique = 0;
                    break;
                }
            }
            
            if (isUnique || j == n - 1) {
                seen[seenCount] = (char*)malloc((strlen(current) + 1) * sizeof(char));
                strcpy(seen[seenCount], current);
                seenCount++;
                
                result[resultCount] = (char*)malloc((strlen(current) + 1) * sizeof(char));
                strcpy(result[resultCount], current);
                resultCount++;
                
                i = j + 1;
                break;
            }
        }
        free(current);
    }
    
    // Free seen array
    for (int i = 0; i < seenCount; i++) {
        free(seen[i]);
    }
    free(seen);
    
    *returnSize = resultCount;
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int returnSize;
    char** result = solution(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Outer loop iterates through string (O(n)), for each position we may extend segment (O(n)), and checking uniqueness requires searching through seen list (O(n))

⚠ Quadratic Growth

Space Complexity

O(n)

List to store seen segments and result array, both can contain up to n segments

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Partition String - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with List Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler