M的奇葩漂流

数组 - 有效的数独

Tue, 14 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/30/

个人解法

测试用例数（个）	执行用时（ms）	战胜
504	184	32.36%

var unvalidCell = function (row, column) {
    return `${ ~~(row / 3) }_${ ~~(column / 3) }`;
}


/**
 * @param {character[][]} board
 * @return {boolean}
 */
var isValidSudoku = function(board) {
    var cache = {};
    var rowNum = board.length;
    var columnNum = board[0].length;

    for (var r = 0 ; r < rowNum ; r++) {
        for (var c = 0 ; c < columnNum ; c++) {
            var num = board[r][c];
            var ucell = unvalidCell(r, c);

            if (num !== '.') {
                if (cache[num]) {
                    var numCache = cache[num];

                    if (numCache.notAllowedRows[r] || numCache.notAllowedColumns[c] || numCache.notAllowedCells[ucell]) {
                        return false;
                    } else {
                        numCache.notAllowedRows[r] = true;
                        numCache.notAllowedColumns[c] = true;
                        numCache.notAllowedCells[ucell] = true;
                    }
                } else {
                    cache[num] = {
                        notAllowedRows: {
                            [r]: true
                        },
                        notAllowedColumns: {
                            [c]: true
                        },
                        notAllowedCells: {
                            [ucell]: true
                        }
                    };
                }
            }
        }
    }

    return true;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
504	104	100%

/**
 * @param {character[][]} board
 * @return {boolean}
 */
var isValidSudoku = function (board) {

        var columns = [{}, {}, {}, {}, {}, {}, {}, {}, {}],
            rows = [{}, {}, {}, {}, {}, {}, {}, {}, {}],
            boxs = [{}, {}, {}, {}, {}, {}, {}, {}, {}];
        for (var i = 0; i < board.length; i++) {
            for (var j = 0; j < board[i].length; j++) {
                var item = board[i][j];

                if (item != ".") {
                    var box_index = Math.floor((i / 3)) * 3 + Math.floor(j / 3);

                    rows[i][item] = rows[i][item] ? rows[i][item] += 1 : 1;
                    columns[j][item] = columns[j][item] ? columns[j][item] += 1 : 1;
                    boxs[box_index][item] = boxs[box_index][item] ? boxs[box_index][item] += 1 : 1;

                    if(rows[i][item]>1 || columns[j][item]>1 || boxs[box_index][item]>1){
                        return false;
                    }
                }
            }
        }
        return true;
    };

分析

数组 - 旋转图像

Tue, 14 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/31/

个人解法

测试用例数（个）	执行用时（ms）	战胜
21	76	98.66%

/**
 * @param {number[][]} matrix
 * @return {void} Do not return anything, modify matrix in-place instead.
 */
var rotate = function(matrix) {
    var len = matrix.length;
    var loopNum = ~~(len / 2);

    for (var i = 0 ; i < loopNum ; i++) {
        for (var j = i ; j < len - i - 1 ; j++) {
            var exchangePoints = [
                [i, j],
                [j, len - i - 1],
                [len - i - 1, len - j - 1],
                [len - j - 1, i]
            ];
    
            var currentValue = matrix[exchangePoints[0][0]][exchangePoints[0][1]];
    
            exchangePoints.forEach(function(point, index) {
                var nextPoint = exchangePoints[(index + 1) % exchangePoints.length];
                var tmp = matrix[nextPoint[0]][nextPoint[1]];
                matrix[nextPoint[0]][nextPoint[1]] = currentValue;
                currentValue = tmp;
            });
        }
    }

    return matrix;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
21	56	100%

/**
 * @param {number[][]} matrix
 * @return {void} Do not return anything, modify matrix in-place instead.
 */

var rotate = function(matrix) {
    var i, j, temp;
    var len = matrix.length;
    for (i = 0; i < len - 1; i++) {
        for (j = i; i + j < len -1; j++) {
            temp = matrix[i][j];
            matrix[i][j] = matrix[len - 1 - j][i];
            matrix[len - 1 - j][i] = matrix[len - 1 - i][len - 1 - j];
            matrix[len - 1 - i][len - 1 - j] = matrix[j][len - 1 - i];
            matrix[j][len - 1 - i] = temp;
        }
    }
};

分析

数组 - 两数之和

Tue, 14 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/29/

个人解法

测试用例数（个）	执行用时（ms）	战胜
29	168	64.74%

var twoSum = function(nums, target) {
    var sortNums = nums.map(function(v, i) {
        return {
            value: v,
            index: i
        }
    }).sort(function(prev, next) {
        return prev.value > next.value
            ? 1 : -1;
    });

    var startIndex = 0;
    var endIndex = sortNums.length - 1;

    while (startIndex < endIndex) {
        var sum = sortNums[startIndex].value + sortNums[endIndex].value;

        if (sum === target) {
            break;
        } else if (sum < target) {
            startIndex++;
        } else {
            endIndex--;
        }
    }

    return [
        sortNums[startIndex],
        sortNums[endIndex]
    ].sort(function(prev, next) {
        return prev.index > next.index ? 1 : -1;
    }).map(function(v) {
        return v.index;
    });
}

最快解法

测试用例数（个）	执行用时（ms）	战胜
21	56	100%

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    const map = {};
    for (let i = 0; i < nums.length - 1; i++) {
        map[target-nums[i]] = i;
        if (nums[i+1] in map) return [map[nums[i+1]], i+1];
    }
}

分析

「最快解法」巧用对象记录差值。

数组 - 移动零

Mon, 13 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/28/

个人解法

测试用例数（个）	执行用时（ms）	战胜
21	96	98.75%

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function(nums) {
    var unZeroIndex = 0;
    
    for (var i = 0 ; i < nums.length ; i++) {
        if (nums[i] !== 0) {
            nums[unZeroIndex] = nums[i];
            unZeroIndex++;
        }
    }

    for (var i = nums.length - 1 ; i >= unZeroIndex ; i--) {
        nums[i] = 0;
    }
    
    return nums;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
21	64	100%

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var moveZeroes = function(nums) {
    var zeroCount = 0;
    for(var i=0; i<nums.length; i++){
       if(nums[i]==0){
           zeroCount ++;
       }else if(zeroCount>0){
           nums[i-zeroCount]=nums[i];
           nums[i] = 0;
       }
    }
};

分析

「个人解法」时间复杂度为 O(2n)，「最快解法」时间复杂度为 O(n)。特别是当数组全为零时，「个人解法」性能最差。

「最快解法」是将非零元素与第一个零元素进行交换。分解过程如下，以 [0,1,0,3,12] 为例：

[0,1,0,3,12]

--> 0,1交换

[1,0,0,3,12]

--> 0,3交换

[1,3,0,0,12]

--> 0,12交换

[1,3,12,0,0]

-->

数组 - 加一

Mon, 13 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/27/

个人解法

测试用例数（个）	执行用时（ms）	战胜
109	84	99.35%

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    for (var i = digits.length - 1 ; i >= 0 ; i--) {
        if (i === digits.length - 1) {
            digits[i] = digits[i] + 1;
        }
        
        if (digits[i] > 9) {
            var remainder = digits[i] % 10;
            var carry = ~~(digits[i] / 10);
            
            digits[i] = remainder;
            
            if (digits[i - 1] !== undefined) {
                digits[i - 1] = digits[i - 1] + carry;
            } else {
                digits.unshift(carry);   
            }
        }
    }
    
    return digits;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
61	56	100%

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    let num = 1,
        i = digits.length;
    while(i) {
        i--;
        if (digits[i] === 9) {
            digits[i] = 0;
            num = 1;
        } else {
            digits[i] += num;
            num = 0;
            break;
        }
    }
    if (!i && num)
        digits.unshift(1);
    return digits;
};

分析

类似大数计算，没啥好说。

数组 - 两个数组的交集 II

Mon, 13 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/26/

个人解法

测试用例数（个）	执行用时（ms）	战胜
61	92	98.88%

var setCache = function (cache, num) {
    if (!cache[num]) {
        cache[num] = 1;
    } else {
        cache[num] = cache[num] + 1;
    }
}

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    var cacheLong = {};
    var cacheShort = {};

    var numsLong = [];
    var numsShort = [];

    var result = [];

    if (nums1.length > nums2.length) {
        numsLong = nums1;
        numsShort = nums2;
    } else {
        numsLong = nums2;
        numsShort = nums1;
    }

    var i = 0;

    while(i < numsLong.length) {
        if (numsLong[i] !== undefined) {
            setCache(cacheLong, numsLong[i]); 
        }
        
        if (numsShort[i] !== undefined) {
            setCache(cacheShort, numsShort[i]); 
        }

        i++;
    }

    for (var k in cacheShort) {
        if (cacheLong[k] && cacheShort[k]) {
            var count = cacheLong[k] > cacheShort[k]
                ? cacheShort[k]
                : cacheLong[k];

            for (var i = 0 ; i < count ; i++) {
                result.push(k);
            }
        }
    }

    return result;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
61	72	100%

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
  const map = {}
  if (nums1.length > nums2.length) [nums1, nums2] = [nums2, nums1]
  nums1.forEach(num => {
    if (!map[num]) map[num] = 1
    else map[num]++
  })
  return nums2.filter(num => {
    if (map[num] > 0) {
      map[num]--
      return true
    }
    return false
  })
};

分析

两种解法本质类似，都是通过 cache 缓存记录次数。

「个人解法」是分别计算出两个数组的 cache 结果，从而进行比较，得出交集。

而「最快解法」中，是只计算出最长数组的 cache 结果，同事将其用到较短数组的过滤逻辑当中，直接得出交集。

进阶问题

如果给定的数组已经排好序呢？你将如何优化你的算法？

var intersect = function (num1, num2) {
    const result = [];

    let n1i = 0;
    let n2i = 0;

    while (num1[n1i] !== undefined && num2[n2i] !== undefined) {
        let n1 = num1[n1i];
        let n2 = num2[n2i];

        if (n1 === n2) {
            result.push(n1);

            n1i++;
            n2i++;
        } else if (n1 > n2) {
            n2i++;
        } else {
            n1i++;
        }
    }

    return result;
}

如果 nums1 的大小比 nums2 小很多，哪种方法更优？

var intersect = function (num1, num2) {
    const cache1 = {};
    const resule = [];
    let matchIndex = 0;

    num1.forEach(v => {
        if (cache1[v]) {
            cache1[v] += 1;
        } else {
            cache1[v] = 1;
        }
    });

    for (let i = 0 ; i < num2.length ; i++) {
        let n2 = num2[i];

        if (matchIndex >= num1.length) {
            break;
        } else {
            if (cache1[n2]) {
                resule.push(n2);

                cache1[n2]--;
                matchIndex++;
            }
        }
    }

    return result;
}

果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

采取分批加载策略，对于每批的算法，同上。

数组 - 存在重复元素

Fri, 10 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/24/

个人解法

测试用例数（个）	执行用时（ms）	战胜
18	120	77.80%

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    var cache = {};
    var len = nums.length;
    
    for (var i = 0 ; i < len ; i++) {
        if (!cache[nums[i]]) {
            cache[nums[i]] = true;
        } else {
            return true;
        }
    }
    
    return false;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
18	72	100%

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    return [...new Set(nums)].length < nums.length
};

分析

通过无序集合 Set 去重得到新数组, 比较新老数组的长度，以此判断，原数据中是否存在重复元素。

按这个思路，对比测试过另一种写法：

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    return (new Set(nums)).size < nums.length
};

从执行速度来看，会稍慢于前者。

数组 - 只出现一次的数字

Fri, 10 May 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/interview/card/top-interview-questions-easy/1/array/25/

个人解法

测试用例数（个）	执行用时（ms）	战胜
16	104	70.88%

/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function(nums) {
    var cache = {};
    var len = nums.length;
    
    for (var i = 0 ; i < len ; i++) {
        cache[nums[i]] = cache[nums[i]] ? (cache[nums[i]] + 1) : 1;
    }
    
    for (var k in cache) {
        if (cache[k] === 1) {
            return k;
        }
    }
    
    return 0;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
16	56	100%

/**
 * @param {number[]} nums
 * @return {number}
 */
var singleNumber = function (nums) {
    var res;
    nums.forEach(function (v) {
        res = res ^ v;
    });
    return res;
};

分析

通过异或巧妙地寻找只出现一次的数字。这里以 [4,1,2,1,2] 为例。

异或运算满足交换律和结合律，即:

(A ^ B) ^ C == C ^ (B ^ A)

所以，我们可以将 [4,1,2,1,2] 进行转换：

4 ^ 1 ^ 2 ^ 1 ^ 2

-->

(1 ^ 1) ^ (2 ^ 2) ^ 4

-->
            
0000 ^ 0000 ^ 0100

-->

0100

-->

4

数组 - 旋转数组

Tue, 26 Mar 2019 00:00:00 +0000

题目

https://leetcode-cn.com/problems/rotate-array/

个人解法

测试用例数（个）	执行用时（ms）	战胜
34	116	70.10%

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    var len = nums.length;
    var originNums = {};
    
    for (var i = 0 ; i < len ; i++) {
        var num = originNums[i] !== undefined
            ? originNums[i]
            : nums[i];

        var nextIndex = (i + k) % len;

        originNums[nextIndex] = nums[nextIndex];
        nums[nextIndex] = num;
    }
    
    return nums;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
34	64	100%

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    let l = nums.length;
    k %= l
    nums.unshift(...nums.splice(nums.length - k, k))
};

分析

此题的关键点如下：

复杂度 O(1) 原地算法

个人解决：

着眼点还是局限在单个元素的旋转上。

最快解决：

将部分作为整体前置，实现整体旋转。视野更高。

数组 - 买卖股票的最佳时机

Mon, 25 Mar 2019 00:00:00 +0000

题目

https://leetcode-cn.com/explore/featured/card/top-interview-questions-easy/1/array/22/

个人解法

测试用例数（个）	执行用时（ms）	战胜
201	1820	1.12%

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    var len = prices.length;
    var maxProfit = 0;

    for (var i = 0 ; i < len ; i++) {
        var index = i;
        var j = i;
        var totalProfit = 0;
        var tProfit = -1;

        while (j < len) {
            j++;

            if (prices[j] !== undefined) {
                var priceDuration = prices[j] - prices[index];

                if (priceDuration > tProfit) {
                    tProfit = priceDuration;
                } else  {
                    totalProfit += tProfit;
                    tProfit = 0;
                    index = j;
                }
            } else {
                totalProfit += tProfit;
                tProfit = 0;
            }
        }

        if (totalProfit > maxProfit) {
            maxProfit = totalProfit;
        }
    }

    return maxProfit;
};

最快解法

测试用例数（个）	执行用时（ms）	战胜
161	56	100%

/**
 * @param {number[]} prices
 * @return {number}
 */
let maxProfit = function(prices) {
    let max = 0;
    for (let i = 1; i < prices.length; i++) {
        if (prices[i] - prices[i - 1] > 0) {
            max += prices[i] - prices[i - 1];
        }
    }
    return max;
}

分析

这个性能差距还是很大的，个人解决还是有些绕。

个人解法：

是当收益总和下降时，卖掉股票。

最快解法：

只要当第二天的股价低于前一天，卖掉股票。