Check if One String Swap Can Make Strings Equal

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];
    }
};

This solution checks whether two strings, string1 and string2, can be made equal with one character swap. The function areStringsEqualByOneSwap evaluates this by analyzing the characters at corresponding positions in both strings. It implements the following steps:

1. Initialize variables firstMismatch and secondMismatch to -1 and discrepancies to 0. These track positions of mismatched characters and the total number of mismatches.
2. Loop through each character in string1 and compare it to the corresponding character in string2.
3. If a mismatch is detected:
   • Increase the count of discrepancies.
   • If discrepancies exceed 2, then more than one swap will be needed, hence return false.
   • Record the index of the first and second mismatches.
4. After looping, ensure there’s exactly two mismatches and that swapping the mismatched characters in string1 with those in string2 would make the strings equal.
5. If the conditions are met, return true, otherwise return false.

This method is efficient for strings with equal lengths and terminates early if more than two mismatches are found, optimizing performance for larger strings.

class Solution {

    public boolean areStringsEqualAfterSwap(String str1, String str2) {
        int diffOne = 0;
        int diffTwo = 0;
        int differenceCount = 0;
        for (int index = 0; index < str1.length(); index++) {
            if (str1.charAt(index) != str2.charAt(index)) {
                differenceCount++;
                if (differenceCount > 2) return false;
                if (differenceCount == 1) {
                    diffOne = index;
                } else {
                    diffTwo = index;
                }
            }
        }
        return (
            str1.charAt(diffOne) == str2.charAt(diffTwo) &&
            str1.charAt(diffTwo) == str2.charAt(diffOne)
        );
    }
}

This Java solution tackles the problem of determining if two strings can be made equal by performing exactly one swap of two characters within one of the strings. The solution implements a method areStringsEqualAfterSwap which checks the conditions under which a single swap would make two strings equal.

• Start by initializing three integer variables: diffOne, diffTwo, and differenceCount, used to track the indices of the characters that differ between the two strings and the total number of differences.
• Use a for loop to iterate over the characters of the strings. Compare the characters at the same position in each string:
  • If they differ, increment the differenceCount.
  • If the count of differences exceeds 2, return false immediately as more than one swap would be needed, which is not allowed by the problem constraints.
  • Record the indices of the first and second differing characters in diffOne and diffTwo.
• After the loop, to successfully return true (indicating one swap can make the strings equal), check that:
  • The character at the first differing index of the first string equals the character at the second differing index of the second string, and vice-versa.
• This method efficiently checks the conditions with a single pass through the strings and simple comparisons, ensuring a quick determination of whether one string swap can make the two strings equal.

class Solution:
    def stringsSimilar(self, str1: str, str2: str) -> bool:
        idx1 = 0
        idx2 = 0
        differences = 0
        for index in range(len(str1)):
            if str1[index] != str2[index]:
                differences += 1
                if differences > 2:
                    return False
                elif differences == 1:
                    idx1 = index
                else:
                    idx2 = index
        return (
            str1[idx1] == str2[idx2] and
            str1[idx2] == str2[idx1]
        )

This function checks whether two strings, str1 and str2, can be made equal by performing at most one swap of two characters within one of the strings. The function proceeds as follows:

1. Initialize two indices, idx1 and idx2, to track the positions of mismatched characters, and a counter, differences, to count these mismatches.
2. Iterate over the characters of the strings using a loop:
   • Compare characters at the same position in str1 and str2.
   • If a mismatch is found:
     • Increment the differences counter.
     • If more than two mismatches are found, return False, as more than one swap would be needed.
     • Record the indices of the first and second mismatches.
3. After the loop, to determine if the strings can be made equal with one swap:
   • Ensure that only two characters differed (recorded in idx1 and idx2).
   • Check that swapping the characters at these indices in str1 would make them equal to the characters at these respective positions in str2.

The function returns True if these conditions are met, indicating that one string swap can make the strings equal, otherwise, it returns False.