Vultr DocsLatest Content

Merge Strings Alternately

Updated on 10 June, 2025
Merge Strings Alternately header image

Problem Statement

The task requires merging two given input strings, word1 and word2, in an alternating pattern, starting with the first letter of word1. The resultant string combines characters from the two strings one by one until one of the strings runs out of characters. If any characters remain in either string after this interleaving, these additional characters are appended directly to the end of the resulting string. Your function must construct and return this merged string following the described pattern.

Examples

Example 1

Input:

word1 = "abc", word2 = "pqr"

Output:

"apbqcr"

Explanation:

 The merged string will be merged as so:
word1: a b c
word2: p q r
merged: a p b q c r

Example 2

Input:

word1 = "ab", word2 = "pqrs"

Output:

"apbqrs"

Explanation:

 Notice that as word2 is longer, "rs" is appended to the end.
word1: a b
word2: p q r s
merged: a p b q r s

Example 3

Input:

word1 = "abcd", word2 = "pq"

Output:

"apbqcd"

Explanation:

 Notice that as word1 is longer, "cd" is appended to the end.
word1: a b c d
word2: p q
merged: a p b q c d

Constraints

  • 1 <= word1.length, word2.length <= 100
  • word1 and word2 consist of lowercase English letters.

Approach and Intuition

The goal is to generate a new string by alternating characters from word1 and word2, starting with word1. The process halts once we reach the end of one string and then appends any remaining characters from the other string. Here's a step-by-step breakdown of how to approach this:

  1. Initialize an empty string result to store the merged characters.
  2. Use a loop to iterate through the characters of word1 and word2. The looping continues until the index exceeds the length of at least one of the strings.
    • Append the current character from word1 to result.
    • Append the current character from word2 to result.
  3. After exiting the loop, check if there are remaining characters in word1 or word2. Append those remaining characters to result.
  4. Return the result string.

Considerations Based on Constraints:

  • With a maximum possible string length of 100 for both strings, the solution needs to handle up to 200 iterations in the worst case, which is computationally feasible.
  • The logic primarily hinges on correctly alternating characters and managing the addition of leftover characters from the longer string.
  • Edge cases include scenarios where:
    • Both strings are of equal length.
    • One string is significantly longer than the other.
    • Exploring minimum length scenarios where one of the strings could just be a single character long.

By iterating through both strings simultaneously and handling the tail end remains, the described approach ensures that all characters are merged according to the rules and constraints given.

Solutions

  • C++
  • Java
  • Python
cpp 
class Solution {
public:
    string interleaveStrings(string str1, string str2) {
        int len1 = str1.length();
        int len2 = str2.length();
        string combined = "";

        for (int index = 0; index < max(len1, len2); index++) {
            if (index < len1) {
                combined.push_back(str1[index]);
            }
            if (index < len2) {
                combined.push_back(str2[index]);
            }
        }

        return combined;
    }
};

The provided C++ solution addresses the problem of merging two strings alternately. The function interleaveStrings takes two strings, str1 and str2, as input parameters. It initiates by determining the length of both input strings and preparing an empty string named combined to store the result.

  • The code uses a for loop that iterates up to the maximum length of the two strings.
  • Within each iteration, the code checks if the current index is within the bounds of the first string (str1). If true, it appends the character at the current index from str1 to the combined string.
  • Similarly, it checks if the index is within the bounds of the second string (str2). If this condition is met, it appends the character at the current index from str2 to combined.

The function returns combined, which is the resultant string with characters alternately merged from str1 and str2. This approach ensures that all characters from both strings are included in the output, even if one string is longer than the other. Also, the function manages to combine the strings in a way that maintains the order of characters from both inputs.

java 
class Solution {
    public String zipStrings(String str1, String str2) {
        int len1 = str1.length();
        int len2 = str2.length();
        StringBuilder combined = new StringBuilder();

        for (int index = 0; index < Math.max(len1, len2); index++) {
            if (index < len1) {
                combined.append(str1.charAt(index));
            }
            if (index < len2) {
                combined.append(str2.charAt(index));
            }
        }

        return combined.toString();
    }
}

The solution to the “Merge Strings Alternately” problem in Java involves creating a method named zipStrings that takes two strings, str1 and str2, as inputs. This method calculates the lengths of these two strings and initializes a StringBuilder to efficiently build the result string through concatenation.

  • The method uses a loop that iterates up to the maximum length of the two input strings.
  • During each iteration, the method checks if the current index is less than the length of str1. If true, the character at the current index of str1 is appended to the StringBuilder.
  • The same check is performed for str2, and if the condition holds, the character at the current index of str2 is appended to the StringBuilder.
  • After the loop completes, the StringBuilder object combined contains the result of merging the two strings alternately. The method then converts this StringBuilder to a string and returns it.

This technique ensures that characters from both strings are added alternately to form a new string, depending on their sequence in the original strings.

python 
class Solution(object):
    def alternateMerge(self, str1, str2):
        merge_result = []
        max_len = max(len(str1), len(str2))
        for index in range(max_len):
            if index < len(str1):
                merge_result += str1[index]
            if index < len(str2):
                merge_result += str2[index]

        return "".join(merge_result)

The given Python program defines a method to merge two strings alternately. The method alternateMerge accepts two strings, str1 and str2, as parameters. Here's the breakdown of how the method works:

  • Initialize an empty list merge_result to store the characters of the merged strings.
  • Calculate the max_len, which is the maximum length of the two input strings. This helps in running the loop until the end of the longer string.
  • Iterate through each index up to max_len. During each iteration:
    • Check if the current index is within the bounds of str1; if yes, append the character at this index from str1 to merge_result.
    • Check if the current index is within the bounds of str2; if yes, append the character at this index from str2 to merge_result.
  • After the loop, join the list merge_result into a single string and return it.

The function effectively merges two strings by alternately appending characters from each string, handling cases where the strings are of unequal lengths without error.

Comments

No comments yet.