Check if One String Swap Can Make Strings Equal

Check if One String Swap Can Make Strings Equal - Problem

You have two strings of equal length, and your task is to determine if you can make them identical by performing at most one character swap on exactly one of the strings.

A string swap operation allows you to choose any two positions in a string (they can be the same position) and exchange the characters at those positions. The challenge is to figure out whether a single such operation can transform one string to match the other perfectly.

Goal: Return true if it's possible to make both strings equal with at most one swap, otherwise return false.

Examples:
• s1 = "bank", s2 = "kanb" → true (swap positions 0 and 2 in s1)
• s1 = "attack", s2 = "defend" → false (too many differences)

Input & Output

example_1.py — Basic Swap Case

$ Input: s1 = "bank", s2 = "kanb"

› Output: true

💡 Note: We can swap characters at positions 0 and 3 in s1: 'bank' → 'kank'. Wait, that's not right. Let me recalculate: swapping positions 0 and 3 gives us 'kank', not 'kanb'. Actually, we need to swap positions 1 and 2: 'bank' → 'bnak'. That's still not right. The correct answer is swapping positions 0 and 2: 'bank' → 'nankb'. I need to be more careful here.

example_2.py — Already Equal

$ Input: s1 = "aa", s2 = "aa"

› Output: true

💡 Note: The strings are already identical, so no swap is needed. This counts as 'at most one swap' since zero swaps is less than one.

example_3.py — Too Many Differences

$ Input: s1 = "attack", s2 = "defend"

› Output: false

💡 Note: These strings have differences at every position. Since one swap can fix at most 2 character positions, it's impossible to make these strings equal with just one swap.

Visualization

Tap to expand

Understanding the Visualization

Count Differences

Compare the strings character by character and count mismatches

Decision Point

Based on difference count: 0→true, 2→check if swappable, other→false

Swap Validation

For 2 differences, verify that swapping those positions fixes both mismatches

Final Answer

Return true only if strings are already equal or can be fixed with exactly one swap

Key Takeaway

🎯 Key Insight: Mathematical constraint - one character swap affects exactly two positions, so it can only fix strings that differ in exactly 0 or 2 positions (and those 2 differences must be complementary).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to find differences

✓ Linear Growth

Space Complexity

O(1)

Only storing at most 4 indices for the different positions

✓ Linear Space

Constraints

1 ≤ s1.length, s2.length ≤ 100
s1.length == s2.length
s1 and s2 consist of only lowercase English letters

Asked in

a Amazon 35 G Google 28 f Meta 22 Apple 15

The optimal solution uses difference counting in O(n) time. Key insight: one swap can fix at most 2 character differences. If strings differ at exactly 2 positions, check if swapping those characters in one string makes them equal. If they're already equal (0 differences) or have exactly 2 fixable differences, return true; otherwise false.

Common Approaches

Approach	Time	Space	Notes
✓ Difference Counting (Optimal)	O(n)	O(1)	Count character differences and check if they can be resolved with one swap
Brute Force (Try All Swaps)	O(n³)	O(1)	Try swapping every pair of characters in one string and check if it matches the other

Difference Counting (Optimal) — Algorithm Steps

Compare strings character by character in one pass
Collect all positions where characters differ
Analyze the number of differences:
- 0 differences: strings already equal → return true
- 2 differences: check if swapping fixes both → return result
- Any other count: impossible with one swap → return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan & Compare

Compare 'bank' and 'kanb' character by character

Find Differences

Mark positions where characters differ: positions 0 and 2

Count Analysis

Found exactly 2 differences - check if they're swappable

Verify Swap

s1[0]='b' should equal s2[2]='n'? No. s1[2]='n' should equal s2[0]='k'? No.

Result

Actually: s1[0]='b'==s2[2]='b' and s1[2]='n'==s2[0]='k'... Wait, let me recalculate

Code -

solution.c — C

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

bool areAlmostEqual(char* s1, char* s2) {
    int differences[1001];
    int diffCount = 0;
    int n = strlen(s1);
    
    // Find all positions where strings differ
    for (int i = 0; i < n; i++) {
        if (s1[i] != s2[i]) {
            differences[diffCount++] = i;
        }
    }
    
    // Analyze the differences
    if (diffCount == 0) {
        return true; // Already equal
    } else if (diffCount == 2) {
        // Check if swapping these two positions in s1 makes it equal to s2
        int i = differences[0];
        int j = differences[1];
        return s1[i] == s2[j] && s1[j] == s2[i];
    } else {
        return false; // Can't fix with one swap
    }
}

int main() {
    char s1[1001], s2[1001];
    scanf("%s %s", s1, s2);
    printf("%s\n", areAlmostEqual(s1, s2) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to find differences

✓ Linear Growth

Space Complexity

O(1)

Only storing at most 4 indices for the different positions

✓ Linear Space

Constraints

1 ≤ s1.length, s2.length ≤ 100
s1.length == s2.length
s1 and s2 consist of only lowercase English letters

31.2K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Difference Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler