LeetCode --- 字符串系列 --- 亲密字符串

亲密字符串

题目

给定两个由小写字母构成的字符串 A 和 B

只要我们可以通过交换 A 中的两个字母得到与 B 相等的结果，就返回 true ；

否则返回 false 。

示例

示例 1：

输入： A = "ab", B = "ba"
输出： true

示例 2：

输入： A = "ab", B = "ab"
输出： false

示例 3：

输入： A = "aa", B = "aa"
输出： true

示例 4：

输入： A = "aaaaaaabc", B = "aaaaaaacb"
输出： true

示例 5：

输入： A = "", B = "aa"
输出： false

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/buddy-strings/

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

1、A 和 B 长度小于 2 或者 
   A 和 B 长度不相等的情况
   直接返回 false

2、两个字符串相等，有重复字符即满足条件

3、长度相等，两个字符串 A、B 不相等
   那么 A、B 顺序对比时，只存在两个不等字符， 
   两个不等字符组成的字符串 Aa 和 Bb ，若 Aa 和 翻转之后的 Bb 相等，才满足条件

力扣教好题解

1、观察题意和案例可以得出结论:
   如果 a 和 b 长度不等，那么一定为 false

2、通过条件：
    1. a 和 b 仅有两个字符不等，并且交换后相等
    2. a 和 b 全等，但是必须有重复字母

题解

// 用时较好，内存消耗较好
执行用时: 68 ms
内存消耗: 35.4 MB

let buddyStrings = function(A, B) {
    let T = '', N = ''
    // A 和 B 长度小于 2 或者 
    // A 和 B 长度不相等的情况
    // 直接返回 false
    if (A.length < 2 || B.length < 2 || A.length !== B.length) return false

    // 两个字符串相等，有重复字符即满足条件
    if (A === B) {
        for (let k = 0; k < A.length; k++) {
            if (A.indexOf(A[k]) !== A.lastIndexOf(A[k])) return true
        }
        return false
    }

    // 长度相等，两个字符串不相等
    for (let i = 0; i < A.length; i++) {
        const element = A[i];
        if (element !== B[i]) {
            // 将不等的字符存起来
            T += element
            // N += B[i]
            // 这里做了翻转操作,新增字符放到字符串前面
            N = B[i] + N
        }
    }
    // 只有两个不等字符，且 翻转之后相等，才满足条件
    if (T.length === 2 && T === N) return true
    return false
}

力扣教好题解

// 用时较好，内存消耗较好
执行用时: 64 ms
内存消耗: 35.5 MB

let buddyStrings = function(A, B) {
    // 长度不相等，肯定不满足条件
    if (A.length !== B.length) return false;

    let notEqualA = '',
        notEqualB = '',
        hasRepeat = false,
        map = new Map();

    // 长度相等
    // 循环
    for (let i = 0, len = A.length; i < len; i++) {
        let a = A.charAt(i), b = B.charAt(i);

        // 若 A、B 当前序号位置的元素不等
        // 分别存储起来
        if (a !== b) {
            notEqualA += a;
            // 倒序存储，方便后面对比是否相等
            notEqualB = b + notEqualB;
        }

        // 判断是否存在重复字符，存在的话，交换重复字符还是等于本身，满足条件
        if (!map.has( a )) {
            map.set( a, 1 );
        } else {
            hasRepeat = true;
        }
    }
    // 若不等字符数为 2 位，且 A 的不等字符串和 B 的倒序不等字符串相等，即满足条件
    // 或
    // 存在重复字符串，且 A 和 B 的不等字符串为空，即 A === B，满足条件
    return (notEqualA.length === 2 && notEqualA === notEqualB) || 
        (hasRepeat && notEqualA.length === 0);
}