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.

1790. Check if One String Swap Can Make Strings Equal
``````struct Solution;

impl Solution {
fn are_almost_equal(s1: String, s2: String) -> bool {
let n1 = s1.len();
let n2 = s2.len();
if n1 != n2 {
return false;
}
let arr: Vec<(char, char)> = s1.chars().zip(s2.chars()).filter(|(a, b)| a != b).collect();
arr.is_empty() || (arr.len() == 2 && arr[0].0 == arr[1].1 && arr[0].1 == arr[1].0)
}
}

#[test]
fn test() {
let s1 = "bank".to_string();
let s2 = "kanb".to_string();
let res = true;
assert_eq!(Solution::are_almost_equal(s1, s2), res);
let s1 = "attack".to_string();
let s2 = "defend".to_string();
let res = false;
assert_eq!(Solution::are_almost_equal(s1, s2), res);
let s1 = "kelb".to_string();
let s2 = "kelb".to_string();
let res = true;
assert_eq!(Solution::are_almost_equal(s1, s2), res);
let s1 = "abcd".to_string();
let s2 = "dcba".to_string();
let res = false;
assert_eq!(Solution::are_almost_equal(s1, s2), res);
let s1 = "caa".to_string();
let s2 = "aaz".to_string();
let res = false;
assert_eq!(Solution::are_almost_equal(s1, s2), res);
}
``````