顺序遍历,求解《1790. 仅执行一次字符串交换能否使两个字符串相等》

2022-10-11 01:51:03
顺序遍历,求解《1790. 仅执行一次字符串交换能否使两个字符串相等》

例题

[1790. 仅执行一次字符串交换能否使两个字符串相等]()

给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下:选出某个字符串中的两个下标(不必不同),并交换这两个下标所对应的字符。
如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等,返回 true ;否则,返回 false 。
示例 1:
输入:s1 = "bank", s2 = "kanb"
输出:true
解释:例如,交换 s2 中的第一个和最后一个字符可以得到 "bank"
示例 2:
输入:s1 = "attack", s2 = "defend"
输出:false
解释:一次字符串交换无法使两个字符串相等
示例 3:
输入:s1 = "kelb", s2 = "kelb"
输出:true
解释:两个字符串已经相等,所以不需要进行字符串交换
示例 4:
输入:s1 = "abcd", s2 = "dcba"
输出:false
提示:
1 <= s1.length, s2.length <= 100
s1.length == s2.length
s1 和 s2 仅由小写英文字母组成

答案

顺序遍历

var areAlmostEqual = function(s1, s2) {
  const n = s1.length
  let j = -1
  for (let i = 0; i < n; i++) {
    if (s1[i] !== s2[i]) {
      if (j === -1) j = i
      else if (j === -2) return false
      else {
        if (s1[i] !== s2[j] || s2[i] !== s1[j]) return false
        j = -2
      }
    }
  }
  return j < 0
};
function areAlmostEqual(s1: string, s2: string): boolean {
  const n = s1.length
  let j = -1
  for (let i = 0; i < n; i++) {
    if (s1[i] !== s2[i]) {
      if (j === -1) j = i
      else if (j === -2) return false
      else {
        if (s1[i] !== s2[j] || s2[i] !== s1[j]) return false
        j = -2
      }
    }
  }
  return j < 0
};
class Solution {
  function areAlmostEqual($s1, $s2) {
    $j = -1;
    $n = strlen($s1);
    for ($i = 0; $i < $n; $i++) {
      if ($s1[$i] !== $s2[$i]) {
        if ($j === -1) $j = $i;
        else if ($j === -2) return false;
        else {
          if ($s1[$i] !== $s2[$j] || $s2[$i] !== $s1[$j]) return false;
          $j = -2;
        }
      }
    }
    return $j < 0;
  }
}
func areAlmostEqual(s1 string, s2 string) bool {
  j := -1
  for i, _ := range s1 {
    if s1[i] != s2[i] {
      if j == -1 {
        j = i
      } else if j == -2 {
        return false
      } else {
        if s1[i] != s2[j] || s2[i] != s1[j] {
          return false
        }
        j = -2
      }
    }
  }
  return j < 0
}
class Solution {
  public boolean areAlmostEqual(String s1, String s2) {
    int j = -1, n = s1.length();
    for (int i = 0; i < n; i++) {
      if (s1.charAt(i) != s2.charAt(i)) {
        if (j == -1) j = i;
        else if (j == -2) return false;
        else {
          if (s1.charAt(i) != s2.charAt(j) || s2.charAt(i) != s1.charAt(j)) return false;
          j = -2;
        }
      }
    }
    return j < 0;
  }
}
public class Solution {
  public bool AreAlmostEqual(string s1, string s2) {
    int n = s1.Length, j = -1;
    for (int i = 0; i < n; i++) {
      if (s1[i] != s2[i]) {
        if (j == -1) j = i;
        else if (j == -2) return false;
        else {
          if (s1[i] != s2[j] || s2[i] != s1[j]) return false;
          j = -2;
        }
      }
    }
    return j < 0;
  }
}
bool areAlmostEqual(char * s1, char * s2){
  int n = strlen(s1), j = -1;
  for (int i = 0; i < n; i++) {
    if (s1[i] != s2[i]) {
      if (j == -1) j = i;
      else if (j == -2) return false;
      else {
        if (s1[i] != s2[j] || s2[i] != s1[j]) return false;
        j = -2;
      }
    }
  }
  return j < 0;
}
class Solution {
public:
  bool areAlmostEqual(string s1, string s2) {
    int n = s1.size(), j = -1;
    for (int i = 0; i < n; i++) {
      if (s1[i] != s2[i]) {
        if (j == -1) j = i;
        else if (j == -2) return false;
        else {
          if (s1[i] != s2[j] || s2[i] != s1[j]) return false;
          j = -2;
        }
      }
    }
    return j < 0;
  }
};
class Solution:
  def areAlmostEqual(self, s1: str, s2: str) -> bool:
    j = -1
    for i, c in enumerate(s1):
      if c != s2[i]:
        if j == -1: j = i
        elif j == -2: return False
        else:
          if c != s2[j] or s2[i] != s1[j]: return False
          j = -2
    return j < 0

栈、顺序遍历,为可变数组添加元素,2 解法求解《1441. 用栈操作构建数组》
栈、顺序遍历,为可变数组添加元素,2 解法求解《1441. 用栈操作构建数组》
顺序遍历,哈希集合,求解《817. 链表组件》
顺序遍历,哈希集合,求解《817. 链表组件》
递归,分治,栈,顺序遍历深度,4 解法求解《856. 括号的分数》
递归,分治,栈,顺序遍历深度,4 解法求解《856. 括号的分数》