Split Strings by Separator

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

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

✓ Brute Force - Manual String Splitting

⏱️ Time: O(n × m) Space: O(k)

For each word, iterate through every character to manually identify separator positions. Build substrings character by character, creating new strings when separators are found. Filter out empty strings from the final result.

Built-in Split Function

⏱️ Time: O(n × m) Space: O(k)

Leverage the built-in string split functionality available in most programming languages. For each word, use the split function with the separator, then filter out any empty strings from the results. This is more efficient and less error-prone than manual processing.

Brute Force - Manual String Splitting — Algorithm Steps

Iterate through each word in the array
For each word, scan character by character to find separators
Build substrings manually and add non-empty ones to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Processing

Process each word character by character

Separator Detection

When separator found, save current substring

Result Collection

Collect all non-empty substrings

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 current[1000] = "";
        int currentLen = 0;
        
        for (int j = 0; word[j]; j++) {
            if (word[j] == separator) {
                if (currentLen > 0) {  // Only add non-empty strings
                    current[currentLen] = '\0';
                    result[*returnSize] = (char*)malloc((currentLen + 1) * sizeof(char));
                    strcpy(result[*returnSize], current);
                    (*returnSize)++;
                }
                currentLen = 0;
            } else {
                current[currentLen++] = word[j];
            }
        }
        
        // Add the last part if it's not empty
        if (currentLen > 0) {
            current[currentLen] = '\0';
            result[*returnSize] = (char*)malloc((currentLen + 1) * sizeof(char));
            strcpy(result[*returnSize], current);
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    char** words = (char**)malloc(1000 * sizeof(char*));
    int wordsSize = 0;
    
    // Read words array
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[\"]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ',' && token[0] != ']' && token[0] != '\n') {
            words[wordsSize] = (char*)malloc((strlen(token) + 1) * sizeof(char));
            strcpy(words[wordsSize], token);
            if (words[wordsSize][strlen(words[wordsSize]) - 1] == '\n') {
                words[wordsSize][strlen(words[wordsSize]) - 1] = '\0';
            }
            if (strlen(words[wordsSize]) > 0) {
                if (words[wordsSize][strlen(words[wordsSize]) - 1] == ']') {
                    words[wordsSize][strlen(words[wordsSize]) - 1] = '\0';
                }
            }
            if (strlen(words[wordsSize]) > 0) {
                wordsSize++;
            }
        }
        token = strtok(NULL, "[\"]");
    }
    
    // Read separator
    char separatorLine[10];
    fgets(separatorLine, sizeof(separatorLine), stdin);
    char separator = separatorLine[0];
    
    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");
    
    // Clean up
    for (int i = 0; i < wordsSize; i++) {
        free(words[i]);
    }
    free(words);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n is total number of words and m is average word length - we examine each character

✓ Linear Growth

Space Complexity

O(k)

Where k is the 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

Brute Force - Manual String Splitting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler