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