Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1790.html

1790. Check if One String Swap Can Make Strings Equal

Level

Easy

Description

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.

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

  • // OJ: https://leetcode.com/problems/check-if-one-string-swap-can-make-strings-equal/
// 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;
    }
};

  • class Solution:
    def areAlmostEqual(self, s1: str, s2: str) -> bool:
        cnt = 0
        c1 = c2 = None
        for a, b in zip(s1, s2):
            if a != b:
                cnt += 1
                if cnt > 2 or (cnt == 2 and (a != c2 or b != c1)):
                    return False
                c1, c2 = a, b
        return cnt != 1

############

# 1790. Check if One String Swap Can Make Strings Equal
# https://leetcode.com/problems/check-if-one-string-swap-can-make-strings-equal/

class Solution:
    def areAlmostEqual(self, s1: str, s2: str) -> bool:
        if s1 == s2: return True
        mp = [0] * 26
        n = len(s1)
        
        for a,b in zip(s1, s2):
            mp[ord(a) - ord('a')] += 1
            mp[ord(b) - ord('a')] -= 1
        
        for v in mp:
            if v != 0: return False
        
        diff = 0
        
        for i in range(n):
            if s1[i] != s2[i]:
                diff += 1
        
        return diff <= 2


  • func areAlmostEqual(s1 string, s2 string) bool {
	cnt := 0
	var c1, c2 byte
	for i := range s1 {
		a, b := s1[i], s2[i]
		if a != b {
			cnt++
			if cnt > 2 || (cnt == 2 && (a != c2 || b != c1)) {
				return false
			}
			c1, c2 = a, b
		}
	}
	return cnt != 1
}

  • function areAlmostEqual(s1: string, s2: string): boolean {
    let c1, c2;
    let cnt = 0;
    for (let i = 0; i < s1.length; ++i) {
        const a = s1.charAt(i);
        const 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;
}


  • impl Solution {
    pub fn are_almost_equal(s1: String, s2: String) -> bool {
        if s1 == s2 {
            return true;
        }
        let (s1, s2) = (s1.as_bytes(), s2.as_bytes());
        let mut idxs = vec![];
        for i in 0..s1.len() {
            if s1[i] != s2[i] {
                idxs.push(i);
            }
        }
        if idxs.len() != 2 {
            return false;
        }
        s1[idxs[0]] == s2[idxs[1]] && s2[idxs[0]] == s1[idxs[1]]
    }
}

All Problems

All Solutions