433.岛屿的个数 （7.2）
给一个01矩阵，求不同的岛屿的个数。
0代表海，1代表岛，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。
样例
[
[1, 1, 0, 0, 0],
[0, 1, 0, 0, 1],
[0, 0, 0, 1, 1],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 1]
]
// 输出3
思路
创建一个visited数组来保存访问过的位置，初始化全为false，访问当前位置则置为true。遍历目标矩阵，没有访问过的点就递归他的上下左右四个点。
程序
function main(arr){
if(!arr||arr.length==0) return 0
const LEN=arr.length
const LEN2=arr[0].length
const row=Array(LEN2).fill(false)
const visited=Array(LEN).fill(row) // 访问过的数组
let res=0
for(let i=0;i<LEN;i++){
for(let j=0;j<LEN2;j++){
if(arr[i][j]&&!visited[i][j]){
DPSlands(arr,visited,i,j)
res++
}
}
}
return res
}
function DPSlands(arr,visited,i,j){
if(i<0||i>=arr.length) return;
if(j<0||j>=arr[0].length) return;
if(!arr[i][j]||visited[i][j]) return;
visited[i][j]=true
DPSlands(arr, visited, i - 1, j);
DPSlands(arr, visited, i, j - 1);
DPSlands(arr, visited, i + 1, j);
DPSlands(arr, visited, i, j + 1);
}
console.log(main(arr)) // 3
457.经典二分查找问题
在一个排序数组中找一个数，返回该数出现的任意位置，如果不存在，返回-1
样例
给出数组 [1, 2, 2, 4, 5, 5].
对于 target = 2, �返回 1 或者 2.
对于 target = 5, �返回 4 或者 5.
对于 target = 6, �返回 -1.
挑战
O(logn) 的时间
const arr=[1, 2, 2, 4, 5, 5]
function findPosition(arr,target){
let start=0,end=arr.length-1,mid=null
let res=[]
if(!arr||target>arr[end]||target<arr[start]) return -1;
while(start<=end){
mid=Math.ceil((end-start)/2)
if(target==arr[mid]) return mid
if(target<arr[mid]){
end=mid
}
if(target>arr[mid]){
start=mid
}
if(arr[start]==target) return start;
if(arr[end]==target) return end;
if(start==end-1) return -1;
}
}
console.log(findPosition(arr,2))//2
488.快乐数 （7.5）
写一个算法来判断一个数是不是"快乐数"。
一个数是不是快乐是这么定义的：对于一个正整数，每一次将该数替换为他每个位置上的数字的平方和，然后重复这个过程直到这个数变为1，或是无限循环但始终变不到1。如果可以变为1，那么这个数就是快乐数。
样例
19 就是一个快乐数。
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
const MAX_TIMES=9999 //设置一个递归的最大次数
function isHappy(num,time){
let sum=0,times=time||0
const str=num.toString()
for(let i=0;i<str.length;i++){
let a=str.charAt(i)
sum+=a*a
times++
}
if(sum==1) return '快乐'
if(times>MAX_TIMES) return '不快乐'
return isHappy(sum,times)
}
console.log(isHappy(19)) //快乐
console.log(isHappy(16)) //不快乐
491.回文数(7.6)
判断一个正整数是不是回文数。
回文数的定义是，将这个数反转之后，得到的数仍然是同一个数。
样例
11, 121, 1, 12321 这些是回文数。
23, 32, 1232 这些不是回文数。
function palindromeNumber(num){
if(!num) return false
const str=num.toString()
if(str.length==1) return true
for(let i=0;i<str.length/2;i++){
if(str.charAt(i)!=str.charAt(Math.abs(str.length-i-1))) return false
}
return true
}
console.log(palindromeNumber(1331)) //true
console.log(palindromeNumber(23)) //false
console.log(palindromeNumber(3)) //true
499.单词计数 (Map Reduce版本) （7.10）
使用 map reduce 来计算单词频率
样例
chunk1: "Google Bye GoodBye Hadoop code"
chunk2: "lintcode code Bye"
Get MapReduce result:
Bye: 2
GoodBye: 1
Google: 1
Hadoop: 1
code: 2
lintcode: 1
实现
const obj={
chunk1: "Google Bye GoodBye Hadoop code",
chunk2: "lintcode code Bye"
}
function WordCount(obj){
let res={}
const arr=Object.keys(obj).reduce((key1,key2)=>{
return obj[key1].split(/\s/).concat(obj[key2].split(/\s/))
})
arr.forEach((word)=>{
res[word]=res.hasOwnProperty(word)?++res[word]:0
})
return res
}
console.log(WordCount(obj)) //Object {Google: 0, Bye: 1, GoodBye: 0, Hadoop: 0, code: 1…}
517.丑数(7.11)
写一个程序来检测一个整数是不是丑数。
丑数的定义是，只包含质因子 2, 3, 5 的正整数。比如 6, 8 就是丑数，但是 14 不是丑数以为他包含了质因子 7。
样例
给出 num = 8，返回 true。
给出 num = 14，返回 false
实现
function isUgly(num){
if(num<=0) return false
if(num==1) return true
const primeNumArr=[2,3,5]
while(num>1){
let divider=-1
for(let i=0;i<primeNumArr.length;i++){
if(num%primeNumArr[i]==0){
divider=primeNumArr[i]
break;
}
}
if(divider==-1) return false
num/=divider
}
return true
}
console.log(isUgly(6)) //true
console.log(isUgly(14)) //false
524.左填充(8.23)
题目链接
实现一个leftpad库，如果不知道什么是leftpad可以看样例
样例
leftpad("foo", 5)
>> " foo"
leftpad("foobar", 6)
>> "foobar"
leftpad("1", 2, "0")
>> "01"
实现
普通实现
function leftpad(str,maxLen,fillStr=' '){
if(arguments.length==0) return false;
if(!maxLen&&!fillStr||str.length>maxLen||isNaN(maxLen)) return str;
let filledStr=''
const filledStrLen=maxLen-str.length
for(let i=0;i<filledStrLen;i++){
filledStr+=fillStr
}
return filledStr.slice(0,filledStrLen)+str
}
console.log(leftpad("foo", 5)) // ' foo'
然而，js怎么会连这么简单的操作都没有封装成一个方法哩OVO，我们可以用padStart()进行实现~~
function leftpad(str,maxLen,fillStr){
return str.padStart(maxLen,fillStr)
}
console.log(leftpad("foo", 5)) // ' foo'
539.移动零(8.24)
给一个数组 nums 写一个函数将 0 移动到数组的最后面，非零元素保持原数组的顺序
题目链接
样例
给出 nums = [0, 1, 0, 3, 12], 调用函数之后, nums = [1, 3, 12, 0, 0].
实现
function moveZeroes(arr){
let len=arr.length
if(!arr||len<1) return;
let i=0
while(i<len){
if(arr[i]===0){
arr.splice(i,1)
arr.push(0)
len--
}else{
i++
}
}
return arr
}
// moveZeroes([4, 0, 0, 3, 12])
// [4, 3, 12, 0, 0]
有前后两个指针，当删除一个元素并在尾部添加一个元素时，后面的指针往前移动，前面的进行遍历的指针保持不动。
547.两数组的交(8.25)
题目链接
返回两个数组的交
结果中的元素必须是唯一的。结果可以是任何顺序。
样例
nums1 = [1, 2, 2, 1], nums2 = [2, 2], 返回 [2].
实现
function intersection(arr1,arr2){
let res=[]
const LEN1=arr1.length
const LEN2=arr2.length
arr1.sort()
arr2.sort()
const Arr=arr1.concat(arr2)
let i=0,j=LEN1
while(i<LEN1&&j<LEN1+LEN2){
if(Arr[i]<Arr[j]){
i++
}else if(Arr[i]>Arr[j]){
j++
}else{
if(Arr[i]!=res[res.length-1]){
res.push(Arr[i])
}
i++
j++
}
}
return res
}
console.log(intersection([1,1,2,2],[2,3,3,6,1])) // [1, 2]
排序后放到一个数组里，和上面那道题的算法差不多，都是用两个指针，只不过另一个是从数组中部遍历。
548.两数组的交 II(8.28)
计算两个数组的交
每个元素出现次数得和在数组里一样
答案可以以任意顺序给出
样例
nums1 = [1, 2, 2, 1], nums2 = [2, 2], 返回 [2, 2].
实现
代码就不举例了，只是把上面那道题最后的判断条件去掉就是此题的解题过程了。
569.各位相加(8.29)
相关链接
给出一个非负整数 num，反复的将所有位上的数字相加，直到得到一个一位的整数。
样例
给出 num = 38。
相加的过程如下：3 + 8 = 11，1 + 1 = 2。因为 2 只剩下一个数字，所以返回 2。
实现
这个就是很简单的递归，在js中要注意类型转换，还有使用reduce时要分配初始值。
function addDigits(num){
if(isNaN(num)) return;
if(num<10) return num
const res=num.toString().split('').reduce((sum,value)=>{
return sum+Number(value)
},0)
return addDigits(res)
}
挑战
你可以不用任何的循环或者递归算法，在 O(1) 的时间内解决这个问题么？
实现
简直玄学~~~
function addDigits(num){
if(num!=0 && num%9==0) return 9;
return num%9;
}
