js编程实现功能

1.编写一个JavsScript函数 fn，该函数有一个参数 n（数字类型, n <=31），其返回值是一个数组，该数组内是 n 个随机且不重复的整数，且整数取值范围是 [2, 32]。（可以使用伪代码） 

       function fn(n,min,max){
           //n最大是31
           if(n>31){
               n=31;
           }
           let allArr=[];//区间内的所有整数组成的数组
           let resAll=[];//n个不重复的数组
            for(let i=0;i<=max-min;i++){
                allArr.push(i+2);
            }
         //从区间中截取出需要的数组  
         for(let j=0;j<n;j++){
             //截取的位置索引
             let spliceArrIndex=Math.floor(Math.random()*(max-min+1-j));
             //spliceArr截取的数组
             let spliceArr=allArr.splice(spliceArrIndex,1)
            resAll=resAll.concat(spliceArr)
         }
         return resAll
       }
       console.log(fn(12,2,32));

 2.请为所有数组对象添加一个通用的remove方法，参数是数组元素的索引值，实现删除指定数组元素的索引的功能。（可以写伪代码）

        Array.prototype.remove=function(order){
            let len=this.length;
            let index=Number(order);//转换为数字的索引
            if(isNaN(index)||index<0||index>=len){
                //不在范围内返回原来的数组
                return this
            }
            for(let i=index;i<len;i++){
                this[i]=this[i+1];
            }
            this.length--;
            return this
        }
        console.log([1,2,3,4,5,6].remove(3))

3.用JS找出一段字符串的最长回文

/* 
出编程题
用JS找出一段字符串的最长回文
*/
let str="aaaaaaaabjjj12345678911987654321gggbaaaaaaaa";
function getBigRepeatWord(str){
    let newStr='';
    let bignewArr=[];
    let allLen=str.length;
    let len=Math.floor(str.length/2);
   for(let i=0;i<=len;i++){
      if(str[i]==str[allLen-1-i]){
        newStr+=str[i];
      }else{
          if(newStr){
              bignewArr.push(newStr);
              newStr='';
          }
      }
      //  //最后的回文如果结束 在加入到数组中
      if(i==len&&newStr){
        bignewArr.push(newStr);
        newStr='';
      }
   }
   console.log(bignewArr);
   let bigVal=bignewArr.reduce((pre,cur,index)=>{
       return pre.length>cur.length?pre:cur
   })
   return "回文最大的内容："+bigVal+","+"回文最大的内容的长度是："+bigVal.length
}
console.log(getBigRepeatWord(str));

4.数组按个位数排序。

//数组按个位数排序。
(function(){
    let arr=[1,3,7,2,111,32,48,52,67,39];
    function sortArr(arr){
        let newArr=[];//生成新的数组 用数组元素和数组的个位数（arr[i]%10除以10就是得到个位数）组成的二位数组
       for(let i=0;i<arr.length;i++){
        newArr.push([arr[i],arr[i]%10])
       }
       //对新的二维数组元素进行排序
       let a=newArr.sort((a,b)=>{
          return a[1]-b[1]
       })
       //二维数组转成一维数组 取每个数组的第一个值
       let lastResArr=newArr.map(v=>v[0])
       return lastResArr
    }
    console.log("数组按个位数排序",sortArr(arr));
})();
//从小到大排序数组
(function(){
    //从小到大排序
    let arr=[1,21,6,11,90,41];
  let newArr=arr.sort((a,b)=>{
      return a-b
  })
  console.log(arr,newArr);
  //查找最小值最大值 newArr[0]最小值  newArr[newArr.length-1]最大值
  console.log(newArr[0],newArr[newArr.length-1])
  console.log(arr,newArr);
  //随机顺序排列数组
  arr.sort((a,b)=>{
      return 0.5-Math.random
  })
  console.log(arr);
})();

5.数组元素和出现个数组成对象key/value返回

function getObjFromArr(arr){
  let obj={};
    for(let i=0;i<arr.length;i++){
      if(!obj[arr[i]]){
        obj[arr[i]]=1
      }else{
          obj[arr[i]]++
      }
    }
    return obj
}
console.log(getObjFromArr([1,3,54,5,2,1,43,3,2]))

6.代码题：快速判断1-100数组中缺失的数字
    元素为1,2,...,100的数组（非有序）中，有一个缺失的数字，如何找到缺失的数组

    输入：99个元素的数组

    输出：缺失的数字

/* 
   代码题：快速判断1-100数组中缺失的数字
    元素为1,2,...,100的数组（非有序）中，有一个缺失的数字，如何找到缺失的数组

    输入：99个元素的数组

    输出：缺失的数字
   */
   let shortArr=[];//缺少的数组
   //缺少的数组生成 随机不加入某个数组
   for(let i=0;i<100;i++){
       shortArr.push(i+1);
   }
   shortArr.splice(Math.ceil(Math.random()*99),1)//[1,2...100] 随机删除一个缺失一个未知元素
    function getNoHasArrElementFn(shortArr){
        let ele;//返回的结果
        let longArr=[];//完整的数组
        let bool=true;//执行一次的一个开关 随机的元素中不生成数组的标识
        //完整的数组生成
        for(let i=0;i<100;i++){
            longArr.push(i+1);
        }//[1,2...100]
        for(let i=0;i<longArr.length;i++){
            //遍历长数组 判断是否出现在短的数组中 不在就返回这个长数组中的元素 
           if(!shortArr.includes(longArr[i])){
               ele=longArr[i];
               break;
           } 
        }
        // console.log(shortArr,longArr);
        return ele
    }
    console.log(getNoHasArrElementFn(shortArr));

7.实现以下输出
    let inArr = [
        {
            company: 'COM1',
            customer: 'CUS1'
        },
        {
            company: 'COM1',
            customer: 'CUS2',
        },
        {
            company: 'COM2',
            customer: 'CUS3'
        }
    ]
    let outArr = [
      {
          company: 'COM1',
          custome: ['CUS1', 'CUS2']
      },
      {
          company: 'COM2',
          custome: ['CUS3']
      }
    ] 

    function getNewArrFn(inArr) {
        let outArr=[];//输出的值
        for (let val of inArr) {
            // debugger
            //不是空数组就判断输出的数组中每个元素的company是不是和inArr中正在遍历的值相等 
            if (outArr.length > 0) {
                outArr.forEach((item, index) => {
                    if (val.company == item.company) {
                        //相等就追加到custom属性中
                        item.custome.push(val.customer)
                    } else {
                        //不相等就在输出数组中追加数组
                        outArr.push({
                            company: val.company,
                            custome: [val.customer],
                        })
                    }
                })
            }
            else {
                //空数组就追加
                outArr.push({
                    company: val.company,
                    custome: [val.customer],
                })
            }
        }
        return outArr
    }

    console.log(JSON.stringify(getNewArrFn(inArr),null,2))

  
       8. 代码题：判断数是否是2的次幂
        判断一个整数num是不是2的次幂
        输入：num
        输出：true或false
       

 function getNum(num){
       
        //循环判断
        while(num%2==0){
                num=num/2
            }
            //最终是1就直接返回true 否则返回false
            if(num==1){
                return true
            }else{
                return false
            }
       
    }
    console.log(getNum(32));

9.问：有一堆桃子，每天吃掉一半，挑出一个坏的扔掉，第6天的时候发现还剩1个桃子，问原来有多少个桃子。

function numT(day) {
	if (day == 6) {
				return 1
	}
	else {
				return (numT(day + 1) + 1) * 2
		}
}
console.log(numT(0));//190

10.写一个 mySetInterVal(fn, a, b),每次间隔 a,a+b,a+2b,...,a+nb 的时间，
 然后写一个 myClear，停止上面的 mySetInterVal 

    function mySetInterval(fn, a, b) {
        this.a = a;
        this.b = b;
        this.time = 0;
        this.hander = -1;
        this.start = () => {
            this.hander = setTimeout(() => {
                fn();
                this.time++;
                this.start();
            }, this.a + this.b * this.time)
        }
        this.stop = () => {
            clearInterval(this.hander)
        }
    }
    let mySet = new mySetInterval(function () {
        console.log('every')
    }, 2000, 1000);
    console.log(mySet.start);
    mySet.start();//开始
//   mySet.stop();//停止

11. 请实现一个函数，输入一个字符串，返回该字符串中不重复的长度最长的连续子串
    如输入 '12432565'，函数应该返回 '43256'(我自己写的。可能不是最好的 或者不对 请多指教)

function maxSubstring(str) {
        //把可能的情况都列出来形成数组  取出数组中最大长度的数值
        let temp = '';
        let arr = [];
        for (let n = 0; n < str.length; n++) {
            for (let i = n; i < str.length; i++) {
                //遍历数组不再空字符中就加入里面 有在的就停止里面的循环 从外边往后开始
                if (temp.indexOf(str[i]) == -1) {
                    temp += str[i];
                } else {
                    arr.push(temp);
                    temp='';
                    break;
                }
            }
        }
        //找出数组中最大的值
        let max=0;
        let maxIndex=0;
        for(let i=0;i<arr.length;i++){
            if(max<arr[i].length){
                max=arr[i].length;
                maxIndex=i;
            }
        }
        return arr[maxIndex]
    }

    console.log(maxSubstring('12432565')); // 43256

12.找到最长的连续不重复的字符串最长前缀

let jjj = ['flash', 'flashman', 'flower']
    let temp = '';
    function maxLengthStr(str) {
        for (let i = 0; i < str[0].length; i++) {
            for (let j = 0; j < str.length-1; j++) {
                    if (str[j][i] != str[j + 1][i]) {
                        return str[0].substr(0,i);//
                    }
            }
        }
    }
    console.log(maxLengthStr(jjj));//fl