基础算法之"数组类"

题目：17. 电话号码的字母组合

思路：先把数组中第一个元素和第二个元素组合成一个新的数组，再跟第三个元素做组合，以此类推。

function comb(arr) {
    // 临时变量用来保存前两个组合的结果
    let tmp = [];

    // 最外层的循环是遍历第一个元素，里层的循环是遍历第二个元素
    for (let i = 0, il = arr[0].length; i < il; i++) {
        for (let j = 0, jl = arr[1].length; j < jl; j++) {
            tmp.push(`${arr[0][i]}${arr[1][j]}`);
        }
    }
    arr.splice(0, 2, tmp);
    if (arr.length > 1) {
        comb(arr);
    } else {
        return tmp;
    }
    return arr[0];
}

function telComb(str) {
    // 建立电话号码键盘映射
    let map = ['', '', 'abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz'];

    // 把输入的字符串按单字符分隔成数组，比如234 => [2,3,4]
    let num = str.split('');

    // 保存键盘映射后的字母内容，比如[2,3,4] => ['abc','def','ghi']
    let code = [];
    num.forEach(item => {
        if (map[item]) {
            code.push(map[item]);
        }
    });

    return comb(code);
}

export default telComb;

题目：914. 卡牌分组

思路：先排序，再根据最大公约数分组归类

// 求两个数的最大公约数
function gcd(a, b) {
    if (b === 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

// 卡牌分组
function card(arr) {
    // 卡牌排序，排序的目的就是为了让相同的牌排在一起方便我们分组
    let str = arr.sort().join('');
    // 分组(单张或多张)
    let group = str.match(/(\d)\1+|\d/g);

    while (group.length > 1) {
        let a = group.shift().length;
        let b = group.shift().length;
        let v = gcd(a, b);
        if (v === 1) {
            return false;   // 没有最大公约数
        } else {
            group.unshift('0'.repeat(v));
        }
    }
    return group.length ? group[0].length > 1 : false;
}

export default card;

题目：605. 种花问题

思路：如果元素的左右两边都是0，那么把该元素设置为1，以此类推知道数组最后

function canPlaceFlowers(arr, n) {
    let count = 0;

    for (let i = 0, len = arr.length; i < len; i++) {
        if (arr[i] === 0) {
            if (i === 0) {
                if (arr[i + 1] === 0) {
                    arr[i] = 1;
                    count++;
                }
            } else if (i === len - 1) {
                if (arr[i - 1] === 0) {
                    arr[i] = 1;
                    count++;
                }
            } else {
                if (arr[i - 1] === 0 && arr[i + 1] === 0) {
                    arr[i] = 1;
                    count++;
                }
            }
        }
    }
    return count >= n;
}

export default canPlaceFlowers;

题目：89. 格雷编码

思路：n的格蕾编码，与n-1的格蕾编码是有关系的

// 递归函数，用来计算输入为n的格雷编码序列
function grayCode(n) {
    let result = [];
    if (n === 1) {
        result = ['0', '1'];
    } else {
        // 取得n-1的格雷编码数组
        let prev = grayCode(n - 1);
        // 计算n的格雷编码长度
        let max = Math.pow(2, n) - 1;
        // 先把n-1的格雷编码数组前面加上0，再以对称的方式在n-1的格雷编码数组前面加上1
        for (let i = 0, len = prev.length; i < len; i++) {
            result[i] = `0${prev[i]}`;
            result[max - i] = `1${prev[i]}`;
        }
    }
    return result.map(item => parseInt(item, 2));
}

export default grayCode;