Split Strings by Separator - Practice Coding Problems

Split Strings by Separator - Problem

Array String Easy

Given an array of strings and a character separator, split each string in the array by the separator.

Return an array of strings containing the new strings formed after the splits, excluding empty strings.

Notes:

The separator is used to determine where the split should occur, but it is not included as part of the resulting strings.
A split may result in more than two strings.
The resulting strings must maintain the same order as they were initially given.

Input & Output

Example 1 — Basic Splitting

$ Input: words = ["one.two.three", "four.five", "six"], separator = "."

› Output: ["one","two","three","four","five","six"]

💡 Note: Split each string by '.': "one.two.three" becomes ["one","two","three"], "four.five" becomes ["four","five"], "six" has no separator so stays ["six"]

Example 2 — Empty Strings Filtered

$ Input: words = ["$easy$", "$problem$"], separator = "$"

› Output: ["easy","problem"]

💡 Note: Split by '$': "$easy$" becomes ["","easy",""], "$problem$" becomes ["","problem",""]. Empty strings are filtered out.

Example 3 — No Separators

$ Input: words = ["hello", "world"], separator = "."

› Output: ["hello","world"]

💡 Note: No separators found, so each word remains as a single string in the result

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
characters in words[i] are either lowercase English letters or characters from the string ".,|$#@" (including the separator)
separator is a character from the string ".,|$#@"

Visualization

Tap to expand

Understanding the Visualization

Input

Array of strings and a separator character

Process

Split each string by separator, filter empty strings

Output

Flattened array of all non-empty substrings

Key Takeaway

🎯 Key Insight: Split each string individually, then flatten and filter the results to maintain order while removing empty strings

Asked in

G Google 15 a Amazon 12 F Facebook 8

The key insight is to process each string by splitting on the separator and filtering out empty results. The optimal approach uses built-in split functions with filtering for clean, efficient code. Time: O(n × m), Space: O(k) where n is number of words, m is average word length, and k is total output length.

Common Approaches

Approach	Time	Space	Notes
✓ Built-in Split Function	O(n × m)	O(k)	Use language built-in split functions and filter empty strings
Brute Force - Manual String Splitting	O(n × m)	O(k)	Manually iterate through each character to find separators and build substrings

Built-in Split Function — Algorithm Steps

Iterate through each word in the array
Use built-in split function on each word
Filter out empty strings and collect all results

Visualization

Tap to expand

Step-by-Step Walkthrough

Built-in Split

Use language split function on each word

Filter Empty

Remove empty strings from split results

Collect Results

Combine all non-empty parts

Code -

solution.c — C

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

char** solution(char** words, int wordsSize, char separator, int* returnSize) {
    char** result = (char**)malloc(1000 * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        char* word = words[i];
        char* token = strtok(word, &separator);
        
        while (token != NULL) {
            if (strlen(token) > 0) {  // Only add non-empty strings
                result[*returnSize] = (char*)malloc((strlen(token) + 1) * sizeof(char));
                strcpy(result[*returnSize], token);
                (*returnSize)++;
            }
            token = strtok(NULL, &separator);
        }
    }
    
    return result;
}

int main() {
    // Simple parsing for demo - in real implementation would parse JSON properly
    char* words[100];
    int wordsSize = 0;
    char separator;
    
    // Read separator
    scanf("%c", &separator);
    
    int returnSize;
    char** result = solution(words, wordsSize, separator, &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 × m)

Where n is number of words and m is average word length - built-in split still needs to examine each character

✓ Linear Growth

Space Complexity

O(k)

Where k is total length of all resulting substrings

✓ Linear Space

23.0K Views

Medium Frequency

~10 min Avg. Time

850 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

Built-in Split Function — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler