Largest Merge Of Two Strings - Practice Coding Problems

Largest Merge Of Two Strings - Problem

You're given two strings word1 and word2, and your task is to create the lexicographically largest merged string possible by following specific merging rules.

Merging Rules:

While either string is non-empty, you must choose one of these operations:
Option 1: Take the first character from word1, append it to your result, and remove it from word1
Option 2: Take the first character from word2, append it to your result, and remove it from word2

Goal: Make the smartest choices to create the lexicographically largest possible merge.

Remember: A string is lexicographically larger if at the first differing position, it has a character that comes later in the alphabet.

Example: If word1 = "cab" and word2 = "dab", the optimal merge is "dcabab" because we greedily pick 'd' first (largest available), then 'c', then 'a', then 'b', then 'a', then 'b'.

Input & Output

example_1.py — Basic Case

$ Input: word1 = "cab", word2 = "dab"

› Output: "dcabab"

💡 Note: We greedily choose the larger character at each step: 'd' > 'c', so pick 'd'. Then 'c' > 'a', so pick 'c'. Then we have 'a' vs 'a', so we compare suffixes "ab" vs "ab" (equal), pick from word1. Continue this process to get "dcabab".

example_2.py — Equal Characters

$ Input: word1 = "abcabc", word2 = "abdaba"

› Output: "abdabacabcabc"

💡 Note: First 'a' vs 'a' - compare suffixes "bcabc" vs "bdaba", choose from word2 since "bdaba" > "bcabc". Continue this suffix comparison strategy when characters are equal.

example_3.py — One Empty String

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

› Output: "abc"

💡 Note: When one string is empty, we simply take all remaining characters from the non-empty string. This is the base case of our algorithm.

Visualization

Tap to expand

Understanding the Visualization

Setup

Position pointers at the start of both strings

Compare

Look at current characters - if different, pick the larger one

Tie-break

If characters are equal, compare entire suffixes to see which leads to a better result

Advance

Move the chosen pointer forward and add character to result

Finish

When one string is exhausted, append all remaining characters from the other

Key Takeaway

🎯 Key Insight: The greedy approach works because comparing suffixes ensures we always make the locally optimal choice that leads to the globally optimal result.

Time & Space Complexity

Time Complexity

⏱️

O((m+n) * min(m,n))

We iterate through both strings once, but suffix comparison in worst case takes O(min(m,n)) time

✓ Linear Growth

Space Complexity

O(m+n)

Only space needed is for the result string of length m+n

⚡ Linearithmic Space

Constraints

1 ≤ word1.length, word2.length ≤ 3000
word1 and word2 consist only of lowercase English letters
The merged string will have length exactly word1.length + word2.length

Asked in

G Google 42 a Amazon 28 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a greedy two-pointer approach with suffix comparison. When characters differ, choose the larger one. When characters are equal, compare remaining suffixes to make the optimal choice. This ensures the lexicographically largest merge in O((m+n) × min(m,n)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Greedy Optimal)	O((m+n) * min(m,n))	O(m+n)	Use greedy strategy with suffix comparison to make optimal choices
Brute Force (Try All Combinations)	O(2^(m+n))	O(m+n)	Generate all possible merges and find the lexicographically largest one

Two Pointers (Greedy Optimal) — Algorithm Steps

Initialize two pointers i=0, j=0 for word1 and word2 respectively
While both pointers are within bounds:
Compare word1[i] and word2[j]
If word1[i] > word2[j], take from word1 and increment i
If word2[j] > word1[i], take from word2 and increment j
If equal, compare suffixes word1[i:] and word2[j:] to decide
Append remaining characters from non-empty string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set pointers i=0, j=0 for both strings

Compare

Compare current characters or suffixes if equal

Choose

Pick the character that leads to lexicographically larger result

Advance

Move the chosen pointer forward and repeat

Finish

Append remaining characters from non-empty string

Code -

solution.c — C

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

int compareSuffixes(const char* word1, const char* word2, int i, int j) {
    return strcmp(word1 + i, word2 + j);
}

char* largestMerge(char* word1, char* word2) {
    int len1 = strlen(word1);
    int len2 = strlen(word2);
    char* result = (char*)malloc((len1 + len2 + 1) * sizeof(char));
    int pos = 0;
    int i = 0, j = 0;
    
    while (i < len1 && j < len2) {
        // Compare suffixes starting from current positions
        if (compareSuffixes(word1, word2, i, j) > 0) {
            result[pos++] = word1[i++];
        } else {
            result[pos++] = word2[j++];
        }
    }
    
    // Append remaining characters
    while (i < len1) {
        result[pos++] = word1[i++];
    }
    while (j < len2) {
        result[pos++] = word2[j++];
    }
    
    result[pos] = '\0';
    return result;
}

int main() {
    char word1[1001], word2[1001];
    fgets(word1, sizeof(word1), stdin);
    fgets(word2, sizeof(word2), stdin);
    
    // Remove quotes and newlines
    word1[strcspn(word1, "\"\n")] = '\0';
    word2[strcspn(word2, "\"\n")] = '\0';
    if (word1[0] == '"') memmove(word1, word1+1, strlen(word1));
    if (word2[0] == '"') memmove(word2, word2+1, strlen(word2));
    
    char* result = largestMerge(word1, word2);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m+n) * min(m,n))

We iterate through both strings once, but suffix comparison in worst case takes O(min(m,n)) time

✓ Linear Growth

Space Complexity

O(m+n)

Only space needed is for the result string of length m+n

⚡ Linearithmic Space

Constraints

1 ≤ word1.length, word2.length ≤ 3000
word1 and word2 consist only of lowercase English letters
The merged string will have length exactly word1.length + word2.length

42.8K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Greedy Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler