js一些常见的代码题

发现写多了手写+力扣，一些简单的题反而用很多数组操作使得性能不好，所以也要多练练。

数组的去重（四种方式）：

const before=[1,2,2,3,3,4,4,1];

const after=[...new Set(before)];

const after2=before.filter((item,index)=>before.indexOf(item)===index);

const after3=[];
before.forEach((item)=>{
  if(!after3.includes(item)){
    after3.push(item);
  }
})

const obj={};
before.forEach(item=>{
  obj[item]=true;
})
const after4=Object.keys(obj);//对象键是字符串，如果不想要字符串可以通过map转换成对应数字
// const after4=Object.keys(obj).map(item=>parseInt(item));

console.log(after);
console.log(after2);
console.log(after3);
console.log(after4);

1.实现一个过滤函数，该函数2个输入值，支持传入2个数组
执行时会从第一个数组内过滤掉第二个数组内的值

const arr = [2, 4, 1, 0, -1, 5, 9, 3, 2, 4, 1, 0, -1, 5, 9];
const fArr = [2, 4, 1, 0, -1];

function filter(arr1,arr2){
  let includes=new Array(arr1.length).fill(true);
  arr1.forEach((item,index)=>{
    if(arr2.includes(item)){
      includes[index]=false;
    }
  })
  let res=[];
  for(let i=0;i<includes.length;i++){
    if(includes[i]){
      res.push(arr1[i])
    }
  }
  return res;
}

2.[‘a’, ‘a’, ‘b’]数组中判断重复最多的key，及次数

function chongfu(arr){
  let res={};
  for(let i=0;i<arr.length;i++){
    let current=arr[i];
    if(!res[current]){
      res[current]=0;
    }else{
      res[current]++;
    }
  }
  return res;
}

3.将数组中type的相同的对象划分到一个数组

arr1=[{type:1,name:'bob'},{type:2,name:'nacy'},{type:1,name:'lili'}]

function classify(arr){
  let res={};
  arr.forEach(item=>{
    if(res[item.type]){
      res[item.type].push(item);
    }else{
      res[item.type]=[item];
    }
  })
  return res;
}
console.log(classify(arr1));
// {
//   '1': [ { type: 1, name: 'bob' }, { type: 1, name: 'lili' } ],
//   '2': [ { type: 2, name: 'nacy' } ]
// }

4.将下面代码根据type归类

let list2 = [
  {
    "name": "古风",
    "type": "风格",
  },
  {
    "name": "放松",
    "type": "情感",
  },
  {
    "name": "民谣",
    "type": "风格",
  },
  {
    "name": "电子",
    "type": "风格",
  },
  {
    "name": "轻音乐",
    "type": "风格",
  },
  {
    "name": "欧美",
    "type": "语种",
  },
  {
    "name": "华语",
    "type": "语种",
  }
]

function classify(arr){
  let res={};
  for(let i=0;i<arr.length;i++){
    if(res[arr[i].type]){
      res[arr[i].type].push(arr[i].name);
    }else{
      res[arr[i].type]=[arr[i].name];
    }
  }
  return res;
}
console.log(classify(list2));

5.原地移除数组中值等于val的数
原地可以用split(),用split的时候别用for循环，len的值会有问题

function deleteVal(arr,val){
  let i=0;
  while(i<arr.length){
    if(arr[i]===val){
      arr.splice(i,1);
    }
    i++;
  }
  return arr;
}
console.log(deleteVal([1,2,4,3,2,3,2,1],1));

或者可以直接从后往前遍历，这样i的值就没问题

function deleteVal(arr,val){
    for(let i=arr.length-1;i>=0;i--){
        if(arr[i]===val){
            arr.splice(i,1);
        }
    }
    return arr;
}

6.判断版本
函数接收两个参数分别为旧版本、新版本，当新版本高于旧版本时表明需要更新，返回true，否则返回false。注意：
// 版本号格式均为"X.X.X"
// X∈[0,9]
// 当两个版本号相同时，不需要更新

function update(oldV,newV){
  let arr1=oldV.split('.');
  let arr2=newV.split('.');
  for(let i=0;i<arr1.length;i++){
    if(arr1[i]<arr2[i]){
      return true;
    }else if(arr1[i]>arr2[i]){
      return false;
    }
  }
  return false;
}

console.log(update('4.6.3','3.5.2'));

7.重写lodashi中的get函数

我们先看lodashi中的get函数
_.get(object, path, [defaultValue])
object (对象): 要查询的对象。
path (路径): 一个数组或字符串，表示要检索的属性路径。
defaultValue (默认值): 可选参数。如果指定的路径在对象上不存在，则返回此默认值。

function lGet(obj,path,defaultValue='default'){
  let pathArr=Array.isArray(path) ? path : path.split('.');
  let value=obj;
  for(let i=0;i<pathArr.length;i++){
    if(value===null){
      return defaultValue;
    }
    if(pathArr[i].includes('[')){
      let key=pathArr[i].slice(0,pathArr[i].indexOf('['));
      let num=pathArr[i].slice(pathArr[i].indexOf('[')+1,pathArr[i].indexOf(']'));
      value=value[key][num];
    }else{
      value=value[pathArr[i]];
    }
    
  }
  return value===null ? defaultValue:value;
}
console.log(lGet(object, 'a[0].b.c'));

8.第一个不重复的字符的索引

function noRepeatKey(str){
  let arr=str.split('');
  for(let i=1;i<arr.length;i++){
    if(arr[i]!==arr[i-1]){
      return i;
    }
  }
}
console.log(noRepeatKey('nng'));

9.实现indexof

function myIndexOf(arr,target){
  for(let i=0;i<arr.length;i++){
    if(arr[i]===target){
      return i;
    }
  }
  return -1;
}
console.log(myIndexOf([1,3,4,2,2],2));

10.不含有重复字符的最长子串的长度

滑动窗口思想

function subStr(str){
  let res={};
  let left=0;
  let max=0;
  for(let i=0;i<str.length;i++){
    if(res[str[i]] && res[str[i]]>=left){
      left=res[str[i]]+1;
    }else{
      res[str[i]]=i;
      max=Math.max(max,i-left+1);
    }
  }
  return max
}

11.红包分配，保证每个人都最少分到一分钱

//给每个人预留一分钱，总钱数的单位是分 保证每个数都是整数避免小数精度不准问题。
//所有人先随机数一遍，再根据每个人的随机数占比分钱。
//最后一个人是剩余的钱。
function hongbao(money,people){
  let sumMoney=money*100-1*people;
  let resMoney=sumMoney;
  let res=[];
  let randomArr=[];
  let randomSum=0;
  for(let i=0;i<people;i++){
    randomArr[i]=Math.random();
    randomSum+=randomArr[i];
  }
  for(let i=0;i<people-1;i++){
    console.log((randomArr[i]/randomSum));
    res[i]=Math.floor((randomArr[i]/randomSum)*sumMoney);
    resMoney-=res[i];
    res[i]=(res[i]+1)/100;
  }
  res[people-1]=(1+resMoney)/100;
  return res;
}

console.log(hongbao(5,5));