Merge Strings Alternately - Leetcode Solution

The problem "Merge Strings Alternately" on LeetCode can be solved using a simple approach of iterating over the two strings simultaneously and taking one character at a time from each string until we reach the end of both strings.

We can start by defining two pointers that point to the first character of each string. Then we can create an empty string that will hold the merged string. Next, we can iterate over both strings until at least one of them reaches its end.

During each iteration, we can add the current character from the first string and the current character from the second string to the merged string. If one of the strings has already ended, we can simply add the remaining characters of the other string to the merged string. Finally, we can return the merged string as the result of the function.

Here's the Python code that implements this approach:

def mergeAlternately(word1: str, word2: str) -> str:
    i = 0
    j = 0
    merged = ""
    while i < len(word1) and j < len(word2):
        merged += word1[i] + word2[j]
        i += 1
        j += 1
    if i < len(word1):
        merged += word1[i:]
    elif j < len(word2):
        merged += word2[j:]
    return merged

The "mergeAlternately" function takes two string arguments "word1" and "word2" and returns a string that contains the merged characters from both strings alternately. The function first initializes two pointers "i" and "j" that point to the first character of each string. It then initializes an empty string "merged" that will hold the merged string. The function then enters a loop that iterates over the two strings until at least one of them reaches its end.

During each iteration, the function adds the current character from the first string and the current character from the second string to the merged string using the "+=" operator. It then increments both pointers "i" and "j" by 1 to move to the next character in each string. If one of the strings has already ended, the function simply adds the remaining characters of the other string to the merged string using string slicing.

Finally, the function returns the merged string as the result.

Overall, this approach has a time complexity of O(n), where n is the length of the longer input string, since we iterate over both strings once. It has a space complexity of O(n) as well, since we create a new string "merged" that holds the merged string.

1