Merge Strings Alternately
Last Updated: March 29, 2026
Understanding the Problem
We have two strings and need to weave them together character by character, alternating between them. Take the first character from word1, then the first from word2, then the second from word1, then the second from word2, and so on.
The twist is that the strings might not be the same length. When we run out of characters in the shorter string, we just tack on whatever is left of the longer string. So this isn't a strict "zip" operation. It's more like a zip that doesn't stop early.
The key observation: we're essentially iterating up to the length of the longer string, grabbing a character from each string when available.
Key Constraints:
1 <= word1.length, word2.length <= 100→ Both strings are very short. Even an O(n * m) approach would only be 10,000 operations. Any reasonable approach will work.word1andword2consist of lowercase English letters → No special characters, no empty strings to worry about.
Approach 1: Two Pointers (Process Both, Then Append Remainder)
Intuition
The first thing that comes to mind is to handle this in two phases. First, walk through both strings in lockstep for as long as both have characters. During this phase, we alternate: one character from word1, one from word2. Once the shorter string runs out, we just append whatever is left from the longer one.
This mirrors how you'd naturally describe the process out loud: "Take turns picking from each string until one runs out, then dump the rest."
Algorithm
- Initialize an empty result (using a
StringBuilderor equivalent). - Use a pointer
istarting at 0. - While
iis less than the length of bothword1andword2: - Append
word1[i]to the result. - Append
word2[i]to the result. - Increment
i. - If
word1has remaining characters (from indexionward), append them all. - If
word2has remaining characters (from indexionward), append them all. - Return the result as a string.
Example Walkthrough
Code
- Time Complexity: O(n + m). We visit every character in both strings exactly once. The first loop runs min(n, m) times, and the remainder loops cover the leftover characters.
- Space Complexity: O(n + m). The result string holds all characters from both inputs. No extra data structures beyond the output.
This approach is already optimal in time and space, but the three separate loops are a bit verbose. Can we handle everything in a single pass?
Approach 2: Single Loop (Optimal and Cleaner)
Intuition
Instead of splitting the work into "interleave phase" and "remainder phase," we can do it all in one loop. Iterate from i = 0 up to the maximum of the two lengths. At each step, if word1 still has a character at index i, add it. If word2 still has a character at index i, add it. That's it.
This naturally handles unequal lengths because the bounds check takes care of everything. When one string runs out, we just skip it and keep adding from the other. No special remainder logic needed.
The single loop iterates up to max(n, m) times. At each iteration, the bounds checks (i < len(word1) and i < len(word2)) ensure we only access valid indices. When one string is exhausted, its check fails and we simply skip it. The "remainder" is handled implicitly: once the shorter string is done, the loop keeps going and only adds characters from the longer one.
The order of the two if statements matters. We check word1 first because the problem says to start with word1. Swapping the order would produce incorrect output.
Algorithm
- Initialize an empty result (using a
StringBuilderor equivalent). - Find the maximum length:
maxLen = max(len(word1), len(word2)). - For
ifrom0tomaxLen - 1: - If
i < len(word1), appendword1[i]. - If
i < len(word2), appendword2[i]. - Return the result as a string.
Example Walkthrough
Code
- Time Complexity: O(n + m). The loop runs max(n, m) times, and inside each iteration we do O(1) work. Total characters processed is exactly n + m.
- Space Complexity: O(n + m). The result string stores all characters from both inputs. No additional data structures are used.