Check if One String Swap Can Make Strings Equal

Problem Statement

In this challenge, you are presented with two strings, s1 and s2, of equal length. Your primary task is to determine if you can make both strings identical by performing a single "string swap" on just one of the two strings. A "string swap" involves choosing any two indices within one string and exchanging the characters at these positions. The function should return true if it's possible to make the strings equal with at most one swap on one string, and return false otherwise.

Examples

Example 1

Input:

s1 = "bank", s2 = "kanb"

Output:

true

Explanation:

For example, swap the first character with the last character of s2 to make "bank".

Example 2

Input:

s1 = "attack", s2 = "defend"

Output:

false

Explanation:

It is impossible to make them equal with one string swap.

Example 3

Input:

s1 = "kelb", s2 = "kelb"

Output:

true

Explanation:

The two strings are already equal, so no string swap operation is required.

Constraints

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

Approach and Intuition

To determine whether one string can be converted to another with at most one swap, consider the following insights and steps derived from the given examples and constraints:

1. Check for Initial Equality: If the two strings s1 and s2 are already identical, no swaps are needed, and the function can immediately return true.

2. Identify Mismatches: Count and compare the positions where the characters in s1 and s2 differ. The outcomes can be:

   • No mismatches: Strings are already the same, return true.
   • Exactly one mismatch: Impossible to solve by one swap, return false.
   • Two mismatches: Investigate further to see if a swap can solve the issue.
   • More than two mismatches: More than one swap needed, so return false.

3. Evaluate Possible Swaps:

   • With exactly two mismatches let:
     • Positions of mismatches in s1 be i and j.
     • Corresponding characters in s2 at these positions be mismatched such that swapping s1[i] with s1[j] makes s1[i] equal to s2[j] and s1[j] equal to s2[i].
   • If the above condition holds after identifying two mismatch positions, return true. Otherwise, return false.

This high-level approach using conditional checks and string manipulations is optimal for the constraints given (string length up to 100), ensuring the solution is efficient and straightforward.

Solutions

class Solution {
public:
    bool areStringsEqualByOneSwap(string string1, string string2) {
        int firstMismatch = -1;
        int secondMismatch = -1;
        int discrepancies = 0;
        for (int idx = 0; idx < string1.length(); idx++) {
            if (string1[idx] != string2[idx]) {
                discrepancies++;
                if (discrepancies > 2)
                    return false;
                if (discrepancies == 1)
                    firstMismatch = idx;
                else
                    secondMismatch = idx;
            }
        }
        return discrepancies != 1 && string1[firstMismatch] == string2[secondMismatch] &&
               string1[secondMismatch] == string2[firstMismatch];
    }
};