js编程实现功能

清疚 2022-12-15 11:25 102阅读 0赞

> 1.编写一个JavsScript函数 fn，该函数有一个参数 n（数字类型, n <=31），其返回值是一个数组，该数组内是 n 个随机且不重复的整数，且整数取值范围是 \[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返回

> 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));