Partition String - Practice Coding Problems

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

Understanding the Visualization

Input

String "abcabc" to be partitioned

Process

Build segments ensuring each is unique

Output

Array of unique segments ["a","b","c","ab","c"]

Key Takeaway

🎯 Key Insight: Use a hash set to track seen segments for O(1) uniqueness checking while building segments incrementally

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

Approach	Time	Space	Notes
✓ Hash Set Optimization	O(n²)	O(n)	Use hash set for O(1) lookup to check if current segment has been seen
Brute Force with List Search	O(n³)	O(n)	Build segments one by one, checking each against a list of seen segments

Hash Set Optimization — Algorithm Steps

Initialize hash set for seen segments
For each position, build segment character by character
Use hash set for O(1) uniqueness check
Add unique segment to result and hash set

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Segment

Extend current segment character by character

Hash Lookup

Check hash set in O(1) time for uniqueness

Add & Continue

Add unique segment to both result and hash set

Code -

solution.c — C

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

#define MAX_SEGMENTS 1000
#define MAX_LENGTH 1000

char seen[MAX_SEGMENTS][MAX_LENGTH];
int seenCount = 0;

int isInSeen(char* segment) {
    for (int i = 0; i < seenCount; i++) {
        if (strcmp(seen[i], segment) == 0) {
            return 1;
        }
    }
    return 0;
}

char** solution(char* s, int* returnSize) {
    int n = strlen(s);
    if (n == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    seenCount = 0;
    char** result = (char**)malloc(n * sizeof(char*));
    int resultCount = 0;
    int i = 0;
    
    while (i < n) {
        char current[MAX_LENGTH] = "";
        
        // Extend current segment until it's unique
        for (int j = i; j < n; j++) {
            int len = strlen(current);
            current[len] = s[j];
            current[len + 1] = '\0';
            
            if (!isInSeen(current)) {
                strcpy(seen[seenCount], current);
                seenCount++;
                
                result[resultCount] = (char*)malloc((strlen(current) + 1) * sizeof(char));
                strcpy(result[resultCount], current);
                resultCount++;
                
                i = j + 1;
                break;
            }
        }
    }
    
    *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 through string positions (O(n)), inner loop to extend each segment (O(n)), hash set lookup is O(1)

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set stores up to n unique segments, result array stores 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Set Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler