Minimum Swaps to Make Strings Equal - Practice Coding Problems

Minimum Swaps to Make Strings Equal - Problem

You are given two strings s1 and s2 of equal length, where each string contains only the characters 'x' and 'y'. Your goal is to make both strings identical by performing the minimum number of character swaps.

The twist? You can only swap characters that belong to different strings. That is, you can swap s1[i] with s2[j] for any valid indices i and j.

Your task: Return the minimum number of swaps required to make s1 and s2 equal, or return -1 if it's impossible.

Example: If s1 = "xx" and s2 = "yy", you can swap s1[0] with s2[0] to get s1 = "yx" and s2 = "xy", then swap s1[1] with s2[0] to get both strings as "xx" or "yy".

Input & Output

example_1.py — Basic Case

$ Input: s1 = "xx", s2 = "yy"

› Output: 1

💡 Note: We can swap s1[0] with s2[1] to get s1="yx", s2="yx". Now both strings are equal with 1 swap.

example_2.py — Multiple Swaps

$ Input: s1 = "xy", s2 = "yx"

› Output: 2

💡 Note: We can swap s1[0] with s2[0] to get s1="yy", s2="xx", then swap s1[1] with s2[1] to get s1="yx", s2="xy". We need 2 swaps total, but we can also make both "xx" or "yy" in 2 swaps.

example_3.py — Impossible Case

$ Input: s1 = "xx", s2 = "xy"

› Output: -1

💡 Note: There are 3 x's and 1 y in total. Since we can only swap characters between strings, we cannot balance them equally. It's impossible to make both strings identical.

Visualization

Tap to expand

Understanding the Visualization

Identify Mismatches

Find positions where the two strings differ

Categorize Patterns

Group mismatches into xy and yx types

Optimal Pairing

Pair mismatches optimally to minimize total swaps

Calculate Result

Apply mathematical formula for minimum swaps

Key Takeaway

🎯 Key Insight: By categorizing mismatches into xy and yx patterns, we can calculate the minimum swaps mathematically without simulation

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to count mismatch patterns

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

1 ≤ s1.length, s2.length ≤ 1000
s1.length == s2.length
s1[i] and s2[i] are either 'x' or 'y'
Both strings contain only characters 'x' and 'y'

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses pattern analysis to count xy and yx mismatches in O(n) time. The key insight is that the minimum swaps needed equals (xy+1)/2 + (yx+1)/2, where each pair of same-type mismatches needs 1 swap and remaining mismatches need 2 swaps each.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(2^n * n)	O(n)	Try all possible swaps until strings become equal
One-Pass Pattern Analysis (Optimal)	O(n)	O(1)	Count mismatch patterns in one pass and calculate minimum swaps mathematically

Brute Force (Try All Swaps) — Algorithm Steps

Generate all possible swap combinations
For each combination, apply swaps and check if strings become equal
Track the minimum number of swaps needed
Return the minimum swaps or -1 if impossible

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original strings s1 and s2

Try Swaps

Systematically try swapping s1[i] with s2[j] for all i,j

Check Equality

After each swap combination, check if strings are equal

Backtrack

Undo swaps and try different combinations

Code -

solution.c — C

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

int trySwaps(char* s1, char* s2, int len, int swapsMade, int* minSwaps) {
    if (strcmp(s1, s2) == 0) {
        if (swapsMade < *minSwaps) {
            *minSwaps = swapsMade;
        }
        return *minSwaps;
    }
    
    if (swapsMade >= *minSwaps) {
        return *minSwaps;
    }
    
    for (int i = 0; i < len; i++) {
        for (int j = 0; j < len; j++) {
            if (s1[i] != s2[j]) {
                char temp = s1[i];
                s1[i] = s2[j];
                s2[j] = temp;
                
                trySwaps(s1, s2, len, swapsMade + 1, minSwaps);
                
                temp = s1[i];
                s1[i] = s2[j];
                s2[j] = temp;
            }
        }
    }
    
    return *minSwaps;
}

int minimumSwap(char* s1, char* s2) {
    int len = strlen(s1);
    int xCount = 0;
    
    for (int i = 0; i < len; i++) {
        if (s1[i] == 'x') xCount++;
        if (s2[i] == 'x') xCount++;
    }
    
    if (xCount % 2 != 0) {
        return -1;
    }
    
    char* temp1 = (char*)malloc((len + 1) * sizeof(char));
    char* temp2 = (char*)malloc((len + 1) * sizeof(char));
    strcpy(temp1, s1);
    strcpy(temp2, s2);
    
    int minSwaps = INT_MAX;
    trySwaps(temp1, temp2, len, 0, &minSwaps);
    
    free(temp1);
    free(temp2);
    
    return minSwaps == INT_MAX ? -1 : minSwaps;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n)

We try all possible combinations of swaps (2^n) and for each combination check if strings are equal (O(n))

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing string copies during swap operations

⚡ Linearithmic Space

Constraints

1 ≤ s1.length, s2.length ≤ 1000
s1.length == s2.length
s1[i] and s2[i] are either 'x' or 'y'
Both strings contain only characters 'x' and 'y'

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler