Merge Strings Alternately - Practice Coding Problems

Merge Strings Alternately - Problem

You are given two strings word1 and word2. Your task is to merge these strings by alternating characters, starting with the first character of word1.

The merging process works as follows:

Take the first character from word1, then the first character from word2
Continue alternating: second character from word1, second character from word2, and so on
If one string is longer than the other, append the remaining characters to the end of the merged result

Example: If word1 = "abc" and word2 = "pqr", the result should be "apbqcr" (a→p→b→q→c→r).

Return the merged string as your final answer.

Input & Output

example_1.py — Basic Case

$ Input: word1 = "abc", word2 = "pqr"

› Output: "apbqcr"

💡 Note: The merged string is formed by alternating characters: a (from word1) + p (from word2) + b (from word1) + q (from word2) + c (from word1) + r (from word2) = "apbqcr"

example_2.py — Different Lengths

$ Input: word1 = "ab", word2 = "pqrs"

› Output: "apbqrs"

💡 Note: After alternating a-p-b-q, word1 is exhausted, so we append the remaining characters "rs" from word2 to get "apbqrs"

example_3.py — First String Longer

$ Input: word1 = "abcd", word2 = "pq"

› Output: "apbqcd"

💡 Note: After alternating a-p-b-q, word2 is exhausted, so we append the remaining characters "cd" from word1 to get "apbqcd"

Constraints

1 ≤ word1.length, word2.length ≤ 100
word1 and word2 consist of lowercase English letters only
At least one of the strings will be non-empty

Visualization

Tap to expand

Understanding the Visualization

Setup Two Decks

Place word1 (blue deck) and word2 (red deck) side by side, with a pointer at the top of each deck

Alternate Picks

Start with blue deck (word1), pick one card, then switch to red deck (word2), pick one card, repeat

Handle Remaining Cards

When one deck runs out, simply take all remaining cards from the other deck and add them to your result pile

Key Takeaway

🎯 Key Insight: By using two pointers and alternating between strings, we can merge them efficiently in a single pass without complex index calculations or multiple string traversals.

Asked in

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

The optimal approach uses two pointers to traverse both strings simultaneously in a single pass. We alternate between the strings using a boolean flag and handle remaining characters naturally when one string is exhausted. This gives us O(n + m) time and O(n + m) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(n + m)	Use two pointers to traverse both strings simultaneously in one pass
Brute Force (Character by Character)	O(n + m)	O(n + m)	Build result string by repeatedly accessing characters at each index

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers, one for each string, starting at index 0
Create a result list or string builder for efficient string construction
Use a boolean flag to alternate between strings
While either pointer hasn't reached the end of its string, add characters alternately
Convert result to string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Place one pointer at the start of each string

Alternate Selection

Use a flag to alternate between strings, advancing the corresponding pointer

Handle Remaining

Continue with remaining characters when one string is exhausted

Code -

solution.c — C

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

char* mergeAlternately(char* word1, char* word2) {
    int len1 = strlen(word1), len2 = strlen(word2);
    char* result = (char*)malloc((len1 + len2 + 1) * sizeof(char));
    
    int i = 0, j = 0, k = 0;
    bool turn = true; // true for word1, false for word2
    
    while (i < len1 || j < len2) {
        if (turn && i < len1) {
            result[k++] = word1[i++];
            turn = false;
        } else if (!turn && j < len2) {
            result[k++] = word2[j++];
            turn = true;
        } else if (i < len1) { // word2 exhausted
            result[k++] = word1[i++];
        } else { // word1 exhausted
            result[k++] = word2[j++];
        }
    }
    
    result[k] = '\0';
    return result;
}

int main() {
    char word1[1001], word2[1001];
    scanf("%s %s", word1, word2);
    char* result = mergeAlternately(word1, word2);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n and m are lengths of word1 and word2. Each character is processed exactly once.

✓ Linear Growth

Space Complexity

O(n + m)

Space for the result string and temporary list/StringBuilder

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~8 min Avg. Time

2.9K 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler