Make Three Strings Equal - Practice Coding Problems

Make Three Strings Equal - Problem

String Easy

You are given three strings: s1, s2, and s3. Your goal is to make all three strings identical by performing a series of operations.

In each operation, you can choose any one of the three strings and delete its rightmost character. However, there's an important constraint: you cannot completely empty a string.

Return the minimum number of operations required to make all three strings equal. If it's impossible to make them equal, return -1.

Example: If you have strings "abc", "ab", and "abcd", you can delete the last character from the first string (1 operation) and the last character from the third string (1 operation) to make all three equal to "ab". Total: 2 operations.

Input & Output

example_1.py — Basic case

$ Input: s1 = "abc", s2 = "abb", s3 = "ab"

› Output: 2

💡 Note: The longest common prefix is "ab". We need to remove 1 character from s1 ("c") and 1 character from s2 ("b"), totaling 2 operations.

example_2.py — Equal length strings

$ Input: s1 = "abc", s2 = "abc", s3 = "abc"

› Output: 0

💡 Note: All three strings are already equal, so no operations are needed.

example_3.py — No common prefix

$ Input: s1 = "abc", s2 = "def", s3 = "ghi"

› Output: -1

💡 Note: The strings have no common prefix, so it's impossible to make them equal by only removing characters from the right.

Constraints

1 ≤ s1.length, s2.length, s3.length ≤ 100
s1, s2, and s3 consist of lowercase English letters only.
You cannot completely empty any string (each final string must have at least 1 character).

Visualization

Tap to expand

Understanding the Visualization

Align papers

Line up the three papers and compare from left to right

Find common text

Identify the longest prefix where all papers have identical text

Mark cutting points

Mark where to cut each paper to achieve the common length

Count cuts

Sum up all the characters that need to be removed

Key Takeaway

🎯 Key Insight: The final equal string must be the longest common prefix of all three input strings, since we can only remove characters from the right end.

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution finds the longest common prefix of all three strings in a single pass. Since we can only remove characters from the right, the final equal string must be a prefix that all three strings share. We compare characters position by position until we find a mismatch, then calculate the total operations needed as the sum of excess characters in each string. Time complexity: O(n) where n is the length of the shortest string.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Lengths)	O(n × m)	O(1)	Try every possible final string length and check if it's achievable
Single Pass Solution (Optimal)	O(n)	O(1)	Find longest common prefix in one pass through the strings

Brute Force (Try All Lengths) — Algorithm Steps

Find the minimum length among all three strings
For each length from min_length down to 1:
Check if all three strings have identical prefixes of this length
If yes, calculate total operations needed (sum of characters to remove)
Return the minimum operations found, or -1 if no valid length exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find minimum length

Determine the shortest string length as our starting point

Try each length

Check if all strings share the same prefix of current length

Calculate operations

Count characters to remove from each string

Return result

Return minimum operations or -1 if impossible

Code -

solution.c — C

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

int findMinimumOperations(char* s1, char* s2, char* s3) {
    int len1 = strlen(s1), len2 = strlen(s2), len3 = strlen(s3);
    int minLen = len1 < len2 ? (len1 < len3 ? len1 : len3) : (len2 < len3 ? len2 : len3);
    int minOps = INT_MAX;
    
    // Try each possible final length
    for (int targetLen = minLen; targetLen >= 1; targetLen--) {
        // Check if all three strings have same prefix of targetLen
        int match = 1;
        for (int i = 0; i < targetLen; i++) {
            if (s1[i] != s2[i] || s2[i] != s3[i]) {
                match = 0;
                break;
            }
        }
        
        if (match) {
            // Calculate operations needed
            int ops = (len1 - targetLen) + (len2 - targetLen) + (len3 - targetLen);
            if (ops < minOps) {
                minOps = ops;
            }
            break; // Found longest valid prefix, this is optimal
        }
    }
    
    return minOps == INT_MAX ? -1 : minOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n is the minimum string length and m is the maximum string length. We check each possible length and compare characters.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track minimum operations and current length.

✓ Linear Space

24.7K Views

Medium Frequency

~12 min Avg. Time

842 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Lengths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler