Adding Spaces to a String - Practice Coding Problems

Adding Spaces to a String - Problem

Transform a string by inserting spaces at specific positions!

You are given a string s and an array of indices spaces. Your task is to insert spaces before the characters at the specified indices to create a new formatted string.

🎯 Goal: Return the modified string with spaces added at the correct positions
📥 Input: A string s and an integer array spaces containing indices
📤 Output: The string with spaces inserted before characters at given indices

Example: Given s = "EnjoyYourCoffee" and spaces = [5, 9], we insert spaces before index 5 ('Y') and index 9 ('C') to get "Enjoy Your Coffee".

Input & Output

example_1.py — Basic Word Separation

$ Input: s = "EnjoyYourCoffee"<br>spaces = [5, 9]

› Output: "Enjoy Your Coffee"

💡 Note: We insert spaces before indices 5 ('Y') and 9 ('C'), creating natural word boundaries to form readable text.

example_2.py — Multiple Small Words

$ Input: s = "icodeinpython"<br>spaces = [1, 5, 7, 9]

› Output: "i code in python"

💡 Note: Spaces are inserted before indices 1, 5, 7, and 9, transforming a concatenated string into separate words.

example_3.py — Single Space at Beginning

$ Input: s = "spacing"<br>spaces = [0]

› Output: " spacing"

💡 Note: A space is inserted at the very beginning (index 0), demonstrating edge case handling for the first position.

Visualization

Tap to expand

Understanding the Visualization

Scan Input

Examine the string and note positions marked for space insertion

Build Result

Process each character, adding spaces when reaching marked positions

Two Pointers

Use one pointer for string position and another for spaces array

Final String

Combine all characters and inserted spaces into final result

Key Takeaway

🎯 Key Insight: Using two pointers allows us to process the string and space positions simultaneously in optimal O(n + m) time, taking advantage of the sorted spaces array to avoid expensive lookups.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through string of length n and spaces array of length m

✓ Linear Growth

Space Complexity

O(n + m)

Space for result string which will have length n + m

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 3 × 10⁴
s consists only of lowercase and uppercase English letters
1 ≤ spaces.length ≤ 3 × 10⁴
0 ≤ spaces[i] ≤ s.length - 1
All the values of spaces are strictly increasing

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Meta 12

The optimal solution uses the two pointers technique to traverse both the input string and spaces array simultaneously in O(n + m) time. Since the spaces array is guaranteed to be sorted, we can process both arrays in a single pass, inserting spaces when the current string index matches the next space position. This approach is more efficient than using a hash set as it takes advantage of the sorted property and uses O(n + m) space only for the result string.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(n + m)	Use two pointers to traverse string and spaces array simultaneously
Brute Force (String Concatenation)	O(n)	O(m + n)	Build result by iterating through each character and checking if we need to add a space

Two Pointers (Optimal) — Algorithm Steps

Initialize result array and two pointers: one for string (i) and one for spaces array (j)
Calculate total result length: original string length + spaces array length
While traversing the string, check if current position matches spaces[j]
If it matches, add a space to result and increment spaces pointer
Always add the current character to result
Continue until all characters are processed
Join result array into final string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set string pointer i=0 and spaces pointer j=0

Compare Positions

Check if current string position matches spaces[j]

Insert Space

If match found, add space and increment spaces pointer

Add Character

Always add current character and increment string pointer

Code -

solution.c — C

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

char* addSpaces(char* s, int* spaces, int spacesSize) {
    int len = strlen(s);
    char* result = malloc(len + spacesSize + 1);
    int resultIdx = 0;
    int spaceIdx = 0;
    
    for (int i = 0; i < len; i++) {
        if (spaceIdx < spacesSize && i == spaces[spaceIdx]) {
            result[resultIdx++] = ' ';
            spaceIdx++;
        }
        result[resultIdx++] = s[i];
    }
    
    result[resultIdx] = '\0';
    return result;
}

int main() {
    char s[1000];
    scanf("%s", s);
    
    int spacesSize;
    scanf("%d", &spacesSize);
    int* spaces = malloc(spacesSize * sizeof(int));
    for (int i = 0; i < spacesSize; i++) {
        scanf("%d", &spaces[i]);
    }
    
    char* result = addSpaces(s, spaces, spacesSize);
    printf("%s\n", result);
    
    free(spaces);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through string of length n and spaces array of length m

✓ Linear Growth

Space Complexity

O(n + m)

Space for result string which will have length n + m

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 3 × 10⁴
s consists only of lowercase and uppercase English letters
1 ≤ spaces.length ≤ 3 × 10⁴
0 ≤ spaces[i] ≤ s.length - 1
All the values of spaces are strictly increasing

28.5K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler