leetcode(领扣)---javascript参考答案

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yipanhuasheng/article/details/84190172

记录一些leetcode上的题，其中涉及到es6语法,可以Ctrl + F自行查找题号。

源码放到github上了，也可以自行下载，复制等。https://github.com/yipanhuasheng/Some_Obj/blob/master/%E7%AE%97%E6%B3%95/js%E5%AE%9E%E7%8E%B0/leetcode.html

[code]<!-- leetcode number 1 -->
var twoSum = function (nums, target) {
var result = [];
var leng = nums.length;
for (var i = 0; i < leng; i++) {
for (var j = i + 1; j < leng; j++) {
if (nums[i] + nums[j] == target) {
result.push(i, j);
continue;
}
}
}
return result;
};
var twoSum1 = function(nums, target) {
let hashTable = [];
for(let i = 0 ; i < nums.length ; i++){
let currentVal = nums[i];
let sub = target - currentVal;

if(hashTable[sub] === undefined)
hashTable[currentVal] = i;
else
return [hashTable[sub], i]
}
};

1题没什么说的，直接二维数组遍历，但是比较慢。

现在想想题感觉之前没读懂，原文是You may assume that each input would have exactly one solution, and you may not use the same element twice.你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。也就是说，不会出现像[2,7,1,8],9这样的参数。

这样第二种方法就显得比较聪明了，如果第一次找到符合答案的，就输出。英文网站用时52ms击败100%，中文网站用时64ms击败99.80%。可见速度神快，你可以输入一组数据，推算一下就知道这个hashTable的用法了。

[code]<!-- leetcode number 771 -->
var numJewelsInStones = function(J, S) {
var Jleng = J.length;
var Sleng = S.length;
var sum = 0;
for (var i = 0; i < Jleng; i++) {
for (var j = 0; j < Sleng; j++) {
if (S[j].indexOf(J[i]) > -1) {
sum++;
}
}
}
return sum;
};

771题，可以用indexOf来确定是否含有。

[code]<!-- leetcode number 929 -->
var numUniqueEmails = function (emails) {
const emailList = new Set();
emails.forEach(item => {
let tempArr = item.split('@');
const local = tempArr[0].split('+')[0].replace(/\./g, '');
emailList.add(
local + '@' + tempArr[1])
});
return [...emailList].length;
};

929题，借鉴大佬的方法，使用了ES6语法中的新数据结构set，它自带去重功能，然后再用[...emailList]重新恢复成数组。

[code]<!-- leetcode number 709 -->
var toLowerCase = function(str) {
return str.toLowerCase();
};

709题，搞笑来的？(╯‵□′)╯︵┻━┻

[code]<!-- leetcode number 349 -->
var intersection = function (nums1, nums2) {
var newset1 = new Set(nums1);
var newset2 = new Set(nums2);
return [...newset1].filter(x => newset2.has(x));
};

349题，借鉴了阮一峰大佬的《ES6入门》，巧妙利用set的has方法。

[code]<!-- leetcode number 344 -->
var reverseString = function(s) {
return s.split("").reverse().join("");
};

344题，比较经典吧，算是。

[code]<!-- leetcode number 371 -->
var getSum = function(a, b) {
let sum, carry;
sum = a ^ b;
carry = (a & b) << 1;
if (carry == 0) {
return sum;
} else {
return getSum(sum, carry);
}
};

371题，可以参考这位仁兄的答案，大致就是说利用异或运算、和运算来分别得到没进位的数和进位的值。

不使用加减运算符实现整数相加（详解）

[code]<!-- leetcode number 905 -->
var sortArrayByParity = function(A) {
var arr = [];
A.forEach(function(val, index){
if(val % 2) {
arr.push(A[index]);
}else{
arr.unshift(A[index]);
}
});
return arr;
};

905题，前边偶数后边奇数，所以就用数组的方法就可以。

[code]<!-- leetcode number 922  -->
var sortArrayByParityII = function(A) {
var ans = new Array(A.length);
var odd = 1,
even = 0;
for (var i = 0; i < A.length; i++) {
if (A[i] % 2 === 0) {
ans[even] = A[i];
even += 2;
} else {
ans[odd] = A[i];
odd += 2;
}
}
return ans;
};

922题，遍历A数组，按照“偶奇偶奇”，对应赋值。

[code]<!-- leetcode number 26 -->
var removeDuplicates1 = function (nums) {
let flag = 0;
for (let i = 1; i < nums.length; i++) {
if (nums[i] !== nums[i - 1]) {
flag++;
nums[flag] = nums[i];
}
}
//console.log(nums);
return flag + 1;
};

26题，不是单纯的返回不同数的长度，里边应该有检测输入数组是否被变成了理想的样子。比如我们输入console.log(removeDuplicates1([1, 1, 2, 2, 2, 3, 3, 3, 4, 5]));那么函数返回的值是5，但是从console.log可以看出传入的nums数组变成了[1, 2, 3, 4, 5, 3, 3, 3, 4, 5]，也就是符合题目要求的样子。

[code]<!-- leetcode number 461 -->
var hammingDistance1 = function (x, y) {
var result = 0;
while (x > 0 || y > 0) {
result += (x % 2) ^ (y % 2);
x >>= 1;
y >>= 1;
}
return result;
};

var hammingDistance2 = function (x, y) {
const binValX = x.toString(2);
const binValY = y.toString(2);
const binArrayX = ("00000000000000000000000000000000".substr(binValX.length) + binValX).split('');
const binArrayY = ("00000000000000000000000000000000".substr(binValY.length) + binValY).split('');
let differences = 0;
for (i = 0; i < binArrayX.length; i++) {
if (binArrayX[i] !== binArrayY[i]) {
differences++;
}
}
return differences;
};

461题，要知道什么是汉明距离，即两个数字对应的二进制位的不同的个数。第一种解法相对较快，x,y对2除余求得两个数字中二进制最后一位，奇数为1，偶数为0，所以就能通过异或求得1加在result上。然后两个数字向右移一位，利用同样的方法。

第二种方法比较容易理解，但是遍历搜索就慢多了，肯定不如操作二进制快得多，其中这么多个0是保证数字为32位。

[code]<!-- leetcode number 832 -->
var flipAndInvertImage = function(A) {
for (var i = 0; i < A.length; i++) {
A[i].forEach((val, index) => val == 1 ? A[i][index] = 0 : A[i][index] = 1);
A[i].reverse();
}
return A;
};

832题，forEach每个数字0,1互换，然后利用数组reverse。

[code]<!-- leetcode number 728 -->
var selfDividingNumbers = function (left, right) {
let result = [];
for (let i = left; i <= right; i++) {
if (i < 10) {
result.push(i);
continue;
}
let tmp = i;
while (tmp > 0) {
let module = tmp % 10;
if (module == 0 || i % module != 0)
break;
tmp = Math.floor(tmp / 10);
}
if (tmp == 0) {
result.push(i);
}
}
return result;
};
var selfDividingNumbers1 = function (left, right) {
var res = [];
return new Array(right - left + 1).fill(0)
.map((val, index) => left + index)
.filter(i => [...(i.toString())].every(digit => i == 0 || i % parseInt(digit, 10) == 0));
};

728题，容易想到第一种解法，利用for循环里套while循环。遍历left到right中的值，在while循环中，排除所有类似10,20,100,200,1000,2000这样的整数，还有对当前的个位检测能否整除，如果可以就缩小十倍（不看小数）直到tmp为0，记录此时的i。

第二种解法是看到外国大佬的，利用数组的方法把数组填充成right - left + 1个0然后再对应赋值成区间中的值，然后通过[...((333).toString())]得到类似["3","3","3"]的数组，再返回数组中的每个元素可以被此时的i值整除或为0的值，即符合要求的值。不过这个方法虽然短，但是耗时没比上一个少多少。

 

 

 

阅读更多