Split Strings by Separator - Practice Coding Problems

Split Strings by Separator - Problem

Array String Easy

Split Strings by Separator

Imagine you have a collection of text documents that need to be broken down into individual words or phrases. Given an array of words and a specific separator character, your task is to split each string in the array by the separator and create a new array containing all the resulting substrings.

Key Requirements:
• Split each string wherever the separator appears
• Exclude empty strings from the result
• The separator itself should not appear in the output
• Maintain the original order of strings and their splits
• A single string may produce multiple splits

Example: If you have ["one.two.three", "four.five"] with separator '.', you should return ["one", "two", "three", "four", "five"].

Input & Output

example_1.py — Basic Split

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

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

💡 Note: The first string splits into 3 parts, second into 2 parts, and third remains as is since it contains no separator.

example_2.py — Empty Strings Filtered

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

› Output: ["easy"]

💡 Note: The first string has empty strings before and after 'easy', and the second string produces only empty strings. All empty strings are filtered out.

example_3.py — No Separators

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

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

💡 Note: Since neither string contains the separator, they are returned unchanged in the result array.

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 20
separator is a single character
words[i] consists of lowercase English letters and separator only

Visualization

Tap to expand

Understanding the Visualization

Load Documents

Start with an array of text documents containing separator characters

Process Each Document

Apply splitting logic to break each document at separator positions

Filter Results

Remove any empty chunks that result from consecutive separators

Collect Output

Combine all valid text chunks into the final result array

Key Takeaway

🎯 Key Insight: Built-in string split functions are highly optimized for this type of text processing, automatically handling edge cases like consecutive separators while maintaining excellent performance.

Asked in

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

The optimal solution uses built-in string split functions to efficiently process each string. For each word, we split by the separator and filter out empty strings. This approach leverages optimized library functions that handle edge cases automatically, resulting in clean, readable code with O(n*m) time complexity where n is the number of words and m is their average length.

Common Approaches

Approach	Time	Space	Notes
✓ Manual Character-by-Character Split	O(n * m)	O(k)	Iterate through each character and manually build substrings
Built-in String Split (Optimal)	O(n * m)	O(k)	Use language built-in string split functions for efficient processing

Manual Character-by-Character Split — Algorithm Steps

Initialize an empty result array
For each string in the input array
Initialize an empty current substring
Iterate through each character in the string
If character is not the separator, add it to current substring
If character is the separator, add current substring to result (if not empty) and reset
After processing all characters, add final substring if not empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty result array and current substring

Process Characters

Iterate through each character, building substrings

Handle Separator

When separator found, save current substring and reset

Complete

Add final substring and move to next word

Code -

solution.c — C

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

char** splitWordsBySeparator(char** words, int wordCount, char separator, int* returnSize) {
    char** result = malloc(1000 * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < wordCount; i++) {
        char* word = words[i];
        char current[1000] = "";
        int currentLen = 0;
        
        for (int j = 0; word[j] != '\0'; j++) {
            if (word[j] == separator) {
                if (currentLen > 0) {
                    result[*returnSize] = malloc((currentLen + 1) * sizeof(char));
                    strcpy(result[*returnSize], current);
                    (*returnSize)++;
                }
                currentLen = 0;
                current[0] = '\0';
            } else {
                current[currentLen] = word[j];
                current[currentLen + 1] = '\0';
                currentLen++;
            }
        }
        
        if (currentLen > 0) {
            result[*returnSize] = malloc((currentLen + 1) * sizeof(char));
            strcpy(result[*returnSize], current);
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"one.two.three", "four.five"};
    int returnSize;
    char** result = splitWordsBySeparator(words, 2, '.', &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%s ", result[i]);
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the total number of strings and m is the average length of each string. We visit each character once.

✓ Linear Growth

Space Complexity

O(k)

Where k is the total number of resulting substrings after splitting

✓ Linear Space

23.4K Views

Medium Frequency

~8 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

Manual Character-by-Character Split — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler