1790. Check if One String Swap Can Make Strings Equal

You are given two strings s1 and s2 of equal length. A string swap is an operation where you choose two indices in a string (not necessarily different) and swap the characters at these indices.

Return true if it is possible to make both strings equal by performing at most one string swap on exactly one of the strings. Otherwise, return false.

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.

Example 4:

Input: s1 = “abcd”, s2 = “dcba”

Output: false

Constraints:

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

Solution

If s1 and s2 are equal to each other, return true. Otherwise, count the number of occurrences of each letter in s1 and s2 and count the number of indices where s1 and s2 differ. The counts of letters’ occurrences should be the same for s1 and s2, and there should be exactly 2 indices where s1 and s2 differ. Return true if the conditions hold, or false otherwise.

JAVA

• class Solution {
      public boolean areAlmostEqual(String s1, String s2) {
          if (s1.equals(s2))
              return true;
          int[] count1 = new int[26];
          int[] count2 = new int[26];
          int length = s1.length();
          int different = 0;
          for (int i = 0; i < length; i++) {
              char c1 = s1.charAt(i), c2 = s2.charAt(i);
              if (c1 != c2)
                  different++;
              count1[c1 - 'a']++;
              count2[c2 - 'a']++;
          }
          if (different != 2)
              return false;
          for (int i = 0; i < 26; i++) {
              if (count1[i] != count2[i])
                  return false;
          }
          return true;
      }
  }
  
  ############
  
  class Solution {
      public boolean areAlmostEqual(String s1, String s2) {
          int cnt = 0;
          char c1 = 0, c2 = 0;
          for (int i = 0; i < s1.length(); ++i) {
              char a = s1.charAt(i), b = s2.charAt(i);
              if (a != b) {
                  if (++cnt > 2 || (cnt == 2 && (a != c2 || b != c1))) {
                      return false;
                  }
                  c1 = a;
                  c2 = b;
              }
          }
          return cnt != 1;
      }
  }

C++

// Time: O(N)
// Space: O(1)
class Solution {
public:
    bool areAlmostEqual(string a, string b) {
        int cnt[26] = {}, diff = 0;
        for (char c : a) cnt[c - 'a'] ++;
        for (char c : b) cnt[c - 'a']--;
        for (int n : cnt) {
            if (n) return false;
        }
        for (int i = 0; i < a.size(); ++i) {
            if (a[i] != b[i]) ++diff;
        }
        return diff == 0 || diff == 2;
    }
};

PYTHON

class Solution:
    def areAlmostEqual(self, s1: str, s2: str) -> bool:
        if s1 == s2:
            return True
        
        diff = [(c1, c2) for c1, c2 in zip(s1, s2) if c1 != c2]
        
        return len(diff) == 2 and diff[0] == diff[1][::-1]