Merge Strings Alternately

Merge Strings Alternately is a warm-up question, but it is a great test of clean pointer handling. You take one character from the first string, then one from the second, then back to the first. The tricky part is what happens when one string is longer than the other. Handle that and you are done.

🎯 The Problem

You get two strings. You weave them together one character at a time. The word for this is interleave. To interleave means to slot the items of one list between the items of another, turn by turn.

The rules:

• Take the first character of string one, then the first of string two.
• Then the second of string one, then the second of string two. Keep going.
• If one string is longer, attach its leftover tail at the end.
• So "ab" and "pqrs" becomes "apbqrs".

Input:  word1 = "abc", word2 = "pqr"
Output: "apbqcr"

Explanation:
  word1:  a   b   c
  word2:    p   q   r
  merged: a p b q c r

Here is the weave shown as the two strings feeding the answer in turn.

🐢 Approach 1: Loop To Shorter Length, Then Append (Brute Force)

The idea in one line: weave up to the shorter length, then attach the leftover tail.

The idea:

• Loop only up to the length of the shorter string.
• In each step, add one character from each string.
• After the loop, one string may still have characters left.
• Attach that whole leftover part at the end.

How it works:

• Find the shorter length first.
• Alternate inside that loop.
• A second step copies the rest of the longer string.

Why it is weak:

• It splits into two pieces of logic. The weave, then the append.
• The leftover step is easy to forget or get wrong.
• It still works and is O(n), but it reads less cleanly than one loop.

Here is the two-phase code for that idea:

def merge_alternately(word1, word2):
    result = []
    limit = min(len(word1), len(word2))

    for i in range(limit):
        result.append(word1[i])
        result.append(word2[i])

    result.append(word1[limit:])
    result.append(word2[limit:])
    return "".join(result)

⚡ Approach 2: One Loop With Two Pointers (Best)

The idea in one line: keep one pointer per string and loop while either one still has characters. A pointer is just an index that says which character you are looking at.

The idea:

• Use two pointers, one for each string.
• Loop while either pointer still has characters left.
• Check each pointer on its own each turn.

How it works:

• If the first pointer is inside its string, add that character and move it forward.
• Then do the same for the second string.
• When one string runs out, its check fails, and only the other keeps adding.

Why it is fast:

• The leftover tail is handled for free. No separate append step.
• Each character is touched once, so time is O(n).
• A string builder keeps adding characters fast, instead of making a new string each time.

Steps to Solve

1. Start two pointers, i and j, both at zero.
2. Create an empty builder to collect characters.
3. Loop while i is inside word1 or j is inside word2.
4. If i is still inside word1, add word1[i] and move i forward.
5. If j is still inside word2, add word2[j] and move j forward.
6. When both pointers are past their strings, stop and return the built string.

Here is the loop weaving "abc" and "pqr". Each turn takes one character from each string while it still has one left.

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

void mergeAlternately(const char *w1, const char *w2, char *out) {
    int len1 = (int)strlen(w1);
    int len2 = (int)strlen(w2);
    int i = 0, j = 0, k = 0;

    while (i < len1 || j < len2) {
        if (i < len1) out[k++] = w1[i++];  // take from word1 if any left
        if (j < len2) out[k++] = w2[j++];  // take from word2 if any left
    }
    out[k] = '\0';
}

int main(void) {
    char out[256];
    mergeAlternately("abc", "pqr", out);
    printf("%s\n", out);
    return 0;
}

apbqcr

#include <iostream>
#include <string>
using namespace std;

string mergeAlternately(string w1, string w2) {
    int i = 0, j = 0;
    string result;

    while (i < (int)w1.size() || j < (int)w2.size()) {
        if (i < (int)w1.size()) result += w1[i++];  // take from w1 if any left
        if (j < (int)w2.size()) result += w2[j++];  // take from w2 if any left
    }
    return result;
}

int main() {
    cout << mergeAlternately("abc", "pqr") << endl;
    return 0;
}

apbqcr

public class MergeAlternately {
    public static String mergeAlternately(String w1, String w2) {
        int i = 0, j = 0;
        StringBuilder sb = new StringBuilder();

        while (i < w1.length() || j < w2.length()) {
            if (i < w1.length()) sb.append(w1.charAt(i++));  // from w1 if left
            if (j < w2.length()) sb.append(w2.charAt(j++));  // from w2 if left
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        System.out.println(mergeAlternately("abc", "pqr"));
    }
}

apbqcr

def merge_alternately(word1, word2):
    i, j = 0, 0
    result = []

    while i < len(word1) or j < len(word2):
        if i < len(word1):           # take from word1 if any left
            result.append(word1[i])
            i += 1
        if j < len(word2):           # take from word2 if any left
            result.append(word2[j])
            j += 1

    return "".join(result)


print(merge_alternately("abc", "pqr"))

apbqcr

function mergeAlternately(word1, word2) {
  let i = 0;
  let j = 0;
  const result = [];

  while (i < word1.length || j < word2.length) {
    if (i < word1.length) result.push(word1[i++]); // from word1 if any left
    if (j < word2.length) result.push(word2[j++]); // from word2 if any left
  }
  return result.join("");
}

console.log(mergeAlternately("abc", "pqr"));

apbqcr

Let us walk through the Python version line by line. We start both pointers i and j at zero. We use a list called result to collect characters. Building a string by adding one character at a time can be slow, so we gather into a list and join once at the end.

The while loop runs while i is inside word1 or j is inside word2. The or is the key. The loop keeps going as long as either string still has characters. So even when one string is finished, the other keeps feeding.

Inside, the first if i < len(word1) checks if the first string still has a character at index i. If yes, we append it and step i forward. The second if j < len(word2) does the same for the second string. Because each check stands on its own, the moment one string runs out its check fails and is skipped. That is how the leftover tail of the longer string gets added without any extra code.

When both pointers pass the ends of their strings, the loop stops. We join the list into one string and return it.

⏱️ Time and Space Complexity

We touch every character of both strings exactly once. So the time is O(m + n), where m and n are the two lengths. We build an answer that holds all those characters, so the space is O(m + n) as well. You cannot do better, since you must read and place every character at least once.

🧩 Key Takeaways

• ✅ Use two pointers and take one character from each string per turn.
• ✅ Loop while either pointer still has characters, using “or” not “and”.
• ✅ Check each pointer on its own, so the longer string’s leftover tail is added for free.
• ✅ Use a string builder or a list, so appending characters stays fast.
• ✅ The whole thing runs in O(m + n) time and space.

🚀 What’s Next?

• Add Strings
• Decode String