一些题∩-∩

胖胖我有点烦

已于 2022-04-21 20:48:11 修改

阅读量1.6k

点赞数 1

分类专栏：全部可见文章标签： leetcode

于 2021-01-20 13:09:08 首次发布

本文链接：https://blog.csdn.net/JiangLittleBai/article/details/109213018

版权

全部可见专栏收录该内容

47 篇文章 2 订阅

订阅专栏

1、生成1到1000之间的质数/素数

质数：除了1和它本身之外不能被其他的数整除。
最小的质数是2

   let result=[];
   for(let i=2;i<=1000;i++){
      const middle=Math.floor(i/2);
      let count=0;
      for(let j=1;j<=middle;j++){
         if(i%j===0){
             count++ 
         }
      }
      if(count==1){
        result.push(i)
      }
   }

2、生成嵌套数组

如题，生成[0,[1,[2,[3]]]]这样的嵌套数组。

let result;
for(let i=3;i>=0;i--){
  if(i==3){
     result=[i];
  }else{
     result=[i,[result]]
  }
}
console.log(result)

3、统计一下从1到n中 0出现的次数

注意：10，出现了1次；；；；；；； 100，出现了2次，1001，出现了2次

先将0到n拼接成一个字符串，然后用0分割

let str=(new Array(10).fill(1)).map(function(item,index){
    return index
})
str=str.toString();
const count=str.split("0").length-1;

4、求两个数的最大公约数

var a=3;
var b=2;
var result;
var ys=1;
while(ys<=a && ys<=b){
   if(a%ys===0  && b%ys===0){
      result=ys;
   }
   ys++;
}
console.log(result)

5、最小公倍数

var a=3;
var b=2;
var min=Math.max(a,b);
var max=a*b;
var result;
for(let i=min;i<=max;i++){
  if(i%a===0 && i%b===0){
      result=i;
      break;
  }
}

6、生成指定长度的字符串

const chars="1234567890qwertyuiopasdfghjklzxcvbnm";
const length=12;
let result="";
for(let i=0;i<length;i++){
   result+=chars[Math.floor(Math.random()*chars.length)]
}
console.log(result)

7、将数组的顺序打乱

现在有数组 [1,2,3,4,5,6,7,8,9,10]，希望把整个数组项的顺序打乱

遍历数组，产生数组长度范围内的随机数，
交换

let arr=[1,2,3,4,5,6,7,8,9,10];
const len=arr.length;
for(let i=0;i<len;i++){
   const index=Math.floor(Math.random()*len);
   const temp=arr[i];
   arr[i]=arr[index];
   arr[index]=temp;
}
console.log(arr)

8、从未排序的整数数组中找出缺失的数字。

比如，有1到100的整数，现在缺少了其中一个，怎么找出这个数字？

解决方式：先求得1到100的和。然后计算出现在存在的这些所有数字的和，两者相减。。。。得出缺失的数字

// 先 求 1到100之间的整数和

9、检查是否有任何两个数字(整数)的和是给定的数字

其他条件：

整数
大于等于零

 const sum=13;
 let x=0;
 let y=sum;
 let result=[];
 while(x<=sum && y>=0){
   if(x+y===sum){
       result.push({
         x:x,
         y:y
       })
       x++;
       y++;
   }
}

10、sort()函数的使用

sort()，将数组项进行排序，直接修改的原数组。sort()会调用每一项的toString()，然后比较得到的字符串，即使数组中的每一项都是数字，sort()比较的也是字符串。

10.1. 日期的大小排序

现有一组日期，格式yyyy-mm-dd，想要从小到大进行排序

const dateArr = ['2018-01-20', '2017-02-19', '2016-08-08', '2018-12-09']
date.sort()// 返回一个新数组

在这里插入图片描述

10.2. 版本号的排序

现有一组版本号,格式为 1.2.3.2 这样的，想要从小到大进行排序

const banben=["1.32.12","1.32.134.3","2.2.23.1","2.3","0.21.1","0.29.1"];
banben.sort();

在这里插入图片描述
10.3. 对象数组按照某个字段值的大小排序

        const sortobj = [{
            name: "沈梦溪",
            height: 154
        }, {
            name: "东皇太一",
            height: 240
        }, {
            name: "百里守约",
            height: 186
        }, {
            name: "蔡文姬",
            height: 132
        }, {
            name: "韩信",
            height: 188
        }];

        sortobj.sort(function (item1, item2) {
            const x = item1.height;
            const y = item2.height;
            if (x < y) {
                return -1
            } if (x > y) {
                return 1
            } else {
                return 0
            }
        });

        console.log(sortobj);

在这里插入图片描述

11、找出数组中第N大的数字

其实这个题目给出的条件是很少的，可以进一步提问。这个数组是有序的吗？排过序的话是升序还是降序？这个数组中有没有重复项呢？

1、好吧，现在设定题目是这样的，数组未排序，然后数组项没有重复项

        // ... 数组排序就不写了啊。。。。
        var paoxuarr = [1, 2, 3, 4, 5, 6, 7];  // 排序 过后的数组
        var count = 0;
        function getNmax(arr, n) {
            for (let i = arr.length - 1; i >= 0; i--) {
                count += 1;
                if (count == n) {
                    console.log(arr[i])
                }
            }
        }
        getNmax(paoxuarr, 3); // 获取第三大的元素

2、数组未排序，数组中有重复项。

        var paoxuarr = [1, 2, 3, 4, 4, 5, 6, 6, 6, 7];
        var count = 0;
        function getNmax(arr, n) {
            for (let i = arr.length - 1; i >= 0; i--) {
                if (i == arr.length - 1) {
                    count += 1;
                }
                if (i < arr.length - 1) {
                    if (arr[i] !== arr[i + 1]) {
                        count += 1;
                    }
                }
                if (count == n) {
                    console.log(arr[i])
                }
            }
        }
        getNmax(paoxuarr, 4);//  找出数组中第四大的 。。。。。

12、找出数组中重复的数组项

好吧，这个问题的解法有很多

解法一

解法一的思路是，使用一个空的新数组a，依次将数组arr的项推入数组a中，如果a中没有这一项，直接推入，，，，，如果数组a中已经有了这一项，那么说明这一项是重复的，直接推入结果数组中

        function findRepeatItem() {
            const arr = [1, 2, 3, 2, 5, 4, 6, 7, 5, 8,3];
            let temp = [];
            let result = [];
            for (let i = 0; i < arr.length; i++) {
                if (!temp.includes(arr[i])) {
                    temp.push(arr[i]);
                } else {
                    result.push(arr[i])
                }
            }
            console.log(result)
        }
        findRepeatItem();

解法二

突然想到，之前数组去重的时候就用到了filter，，，，那反过来也可以使用它来得到重复的数组项。。。。。

            const arr = [1, 2, 3, 2, 5, 4, 6, 7, 5, 8,3];
            let koko=[];
            koko=arr.filter(function(item,index){
               return arr.indexOf(item)!==index
            });
            console.log(koko);

13、空格替换，将字符串中的每一个空格替换为`%20`

粗略想了一下，

使用函数encodeURIComponent()或者 encodeURI()，好吧，这个方法有风险，万一这个字符串中有其他的符号（空格、中文、特殊字符什么的也会被转译。。。那这就偏离了题目了。。。）所以这个方法不建议用
使用正则进行替换
新声明一个变量res,遍历当前字符串，如果当前字符是空格，将其替换为20%，写入到变量res中

const strr="   hello mengmeng   honghong  ss    ji   d    ddddd  ";
encodeURI(strr);
encodeURIComponent(strr);


// 正则方式
const resultReplaceStr=spacestr.replace(/\s/g,"%20");
console.log(resultReplaceStr);

// 遍历当前字符串，替换空格为%20， 
        let spaceReplaceStrr="";
        for(let i=0;i<spacestr.length;i++){
            if(spacestr[i]===" "){
                spaceReplaceStrr+="%20";
            }else{
                spaceReplaceStrr+=spacestr[i];
            }
        }
        console.log(spaceReplaceStrr);

14、连续子数组的最大和

输入一个整型数组，数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和，求所有子数组和的最大值。
例如输入的数组为1,-2,3,10,-4,7,2,-5，和最大的子数组为3,10,-4,7,2，因此输出为该子数组的和18。

        function zuidahe() {
            var arr = [1, -2, 3, 10, -4, 7, 2, -5];
            var arr=[1, -2, 3, 10, -4, 7, 2, -5,11,23,-9,43,12,1];
            var res = 0;
            var temp = 0;
            for (let i = 0; i < arr.length; i++) {
                if (temp + arr[i] > res) {
                    res = temp + arr[i];
                } else {
                    temp = res
                }
            }
            console.log(res)
        }
        zuidahe();

15、二分查找

二分查找一般是针对一个排序数组的，

        function divide() {
            var arr = [1, 2, 3, 4, 5, 6, 12, 34, 234, 1234, 1243, 1254, 1354, 1456];
            var target = 3;
            var start = 0;
            var end = arr.length - 1;
            while (start < end) {
                var middle = arr[Math.floor((start + end) / 2)];
                if (middle === target) {
                    console.log("找到了", '---000', middle)
                    break;
                } else if (middle < target) {
                    start = middle + 1;
                } else if (middle > target) {
                    end = middle - 1;
                }
            }
            if (start === end) {
                console.log("找不到")
            }
            console.log(start, end);
  }
  divide();

16、实现一个简单的模板渲染

写一个函数，根据下面的模板和输入的值，生成我是坤坤，特长是篮球，代表作姬霓太美

现有模板内容：我是{{name}}，爱好是{{address}}，代表作{{dw}}
输入data，data={name:"坤坤",address:"篮球",dw:"姬霓太美"}

解决方式：写个正则替换一下吧。。。。。

        function render(template, data) {
            const pt = /\{\{[\w]+\}\}/g
            template = template.replace(pt, function (item) {
                const ptt = /(\w+)/;
                const hh = item.match(ptt);
                if (hh) {
                    console.log(data[hh[1]])
                    return data[hh[1]]
                }
            });
            console.log(template)
        }

        const templatee = "我是{{name}},特长是{{address}},代表作{{dw}}";
        const renderdata = {
            name: "坤坤",
            address: "篮球",
            dw:"姬霓太美"
        }
        render(templatee, renderdata);

在这里插入图片描述

17、数组的翻转

解释：现有数组[1,2,3,4,5]，将这个数组的项的顺序整个翻转，得到[5,4,3,2,1。不可以使用reverse() 等函数。原生发生实现

解题思路：找到数组的中间位置，按顺序依次将中间位置的前面和后面的数字交换。直到数组的边界处

        function fanzhuan() {
            let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]; //翻转后[9,8,7,6,5,4,3,2,1]
            const length = arr.length;
            let left;
            let right;
            let midIndex;
            if (length % 2 === 0) {
                midIndex = length / 2;
                left = midIndex - 1;
                right = midIndex;
                console.log(left, right)
            } else {
                midIndex = Math.floor(length / 2);
                left = midIndex - 1;
                right = midIndex + 1;
            }
            // 交换left 和 right 位置的数字
            while (left >= 0) {
                const temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left--;
                right++;
            }
            console.log(arr);
        }
        fanzhuan();

18、使用堆栈实现队列先进先出的效果

堆栈：先进后出，每次只能从队列的顶部取数据，存数据时也只能从放到顶部。

队列：先进先出，就像是排队，排在前面的先出去，排在后面的后出来。

如果想要用堆栈去模拟队列的效果的话，至少需要2个堆栈A和堆栈B。
当有数据输入时，就往堆栈A里插入push()。当有是数据输出时，就将堆栈A中的数据依次拿出来放入堆栈B中，再从堆栈B的顶部取出数据。由此，便通过2个堆栈实现了队列的先进先出的效果了。

添加链接描述

19、使用队列实现堆栈先进后出的效果

队列：先进先出，就像是排队买票，排在队列前面的先出去，不可以插队。

堆栈：后劲先出，就像是一个桶，每次存数据时总是存放到最上面，取数据时也是从上面取数据

如果想要用队列实现堆栈先进后出的效果

20、找出数组的项的最大差值

题目解释：在一个整数数组中，求两个数组项相减之后的最大差值

不让用array 数组自带的方法的话，就遍历，求出最小值和最大值，相减

        var arr = [4, 2, 12, 3, 1, 9, 132, 54, 24, 1];
        var arr = [-14, -2, 7, 5, 11, 13, 9, 1];
        var min=arr[0];
        var max=arr[0];
        for(let i=1;i<arr.length;i++){
            if(min>arr[i]){
                min=arr[i]
            }
            if(arr[i]>max){
                max=arr[i]
            }
        } 
        console.log(min,max,max-min)

21、若無序数组中存在两项的和等于目标值，返回其下标(只返回一組就行)

好吧，这个问题，一开始想到的是双层for循环，同时从数组的第一项和最后一项遍历，判断两项的和是否等于目标值，是的话，返回下标。。。。。。。但是这个方法时间复杂度 o(n²)。。。。有没有更好的方法呢？

22、有序数组中存在两项的和等于目标值，返回其下标（只返回一組就行）

好吧，有序数组的话，就简单的一些

        function summ(arr, target) {

            if (!arr || arr.length < 2) {
                console.log("不存在");
                return false;
            } else {
                var result = [];
                var left = 0;
                var right = arr.length - 1;
                while (left < right) {
                    var total = arr[left] + arr[right];
                    if (total === target) {
                        console.log(left, right, '0000000');
                        break;
                    } else if (total > target) {
                        right--;
                    } else if (total < target) {
                        left++
                    }
                }
                console.log("找不到 兩個數組項 和為 目標值")
            }
        }
        var arr = [1, 2, 3, 4, 5, 6, 7, 8];
        summ(arr, 14);
        summ(arr, 17);

23、判断一组括号的嵌套是否合法

()[]{}、{{}()[()]}等等这样的是合法的
(()、[[}](、][、}}[])等等这样的是不合法的

首先，如果括号的个数是奇数，那肯定不合法。合法的括号都是成对出现、、、

        function judge(str) {
            if (!str || str.length % 2 !== 0) {
                console.log("不合法");
                return false
            } else {
                var arr = [];
                var cu=""
                for (var i = 0; i < str.length; i++) {
                     cu = str[i];
                    if (cu === '[' || cu === '(' || cu === "{") {
                        arr.push(cu);
                    } else {
                        var top = arr.pop();
                        if (cu === ")" && top !== "(") {
                            console.log("不合法")
                            return false
                        } else if (cu === "]" && top !== "[") {
                            console.log("不合法");
                            return false
                        } else if (cu === "}" && top !== "{") {
                            console.log("不合法");
                            return false
                        }
                    }
                }
                if(arr.length){
                    console.log("不合法");
                    return false
                }
            }
        }
        judge("]]][")
        judge("()[]{()[()]}}")

24、返回两个数组的交集

解释：数组项同时存在于数组a和数组b中。[1,2,3,4]和[3,4,5,6]的交集就是[4]

好吧，求数组交集的方法还是比较多的。。。for循环，filter

25、有6个人为一个运动员打分、分数都是整数、最低分是1分，最高分是5分。求一个平均分。问。。。这个运动员可能拿到的平均分有多少种情况。。。

那首先，平均分是在总分的基础上计算出的。。那可以先思考下总分的情况。。。如果6个人都打1分，那总分是6分。如果6个人都打5分，那么总分是30分。也就是说，总分的范围是6~30分。共有25种总分

那么平均分也是 25种了。。。

26、在一个给定的数组中，找出由三个数组项得到的最大乘积，有负数的话得考虑负负得正的情况。假设数组长度至少是3

解题思路一：先数组从小到大排序，如果都是正数，最大乘积等于最后3个数组项的乘积；如果都是负数，最大乘积等于最前面3个数组项的乘积。如果有正数有负数，最大乘积要不是最小两个负数和最大整数的乘积就是最大三个整数的乘积

    var arr = [1, 2, 3, 4, 5, 56, 6, 9];
    var result; // 存放最大乘积
    // 先给数组排序，冒泡、快速都行。。 排序结果是从小到大
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - i - 1; j++) {
            if (arr[j + 1] < arr[j]) {
                const temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    var min = arr[0];
    var max = arr[arr.length - 1];
    var len = arr.length;
    if (min >= 0 && max >= 0) { // 最小值大于等于0 ，那最大乘积等于最大的3项的乘积
        result = arr[len - 1] * arr[len - 2] * arr[len - 3];
    } else if (min < 0 && max < 0) { // 最大值小于0，那最大乘积等于最大的3项的乘积
        result = arr[len - 1] * arr[len - 2] * arr[len - 3];
    } else { // 数组项有正有负
        var temp1 = arr[len - 1] * arr[len - 2] * arr[len - 3];
        var temp2 = arr[0] * arr[1] * arr[len - 1];
        result = temp1 > temp2 ? temp1 : temp2
    }
    console.log(result, '999')

解题思路二：根据解题思路1可以在知道，最大乘积一定是在最大的前3项和最小的后2项之间相乘得到，，，那只要得到这几项就不需要排序了

27、两个排序数组的合并

现在，有两个数组a和b 都是升序的，想要将这两个数组合并为一个新数组之后仍然保持升序，不要使用sort()、concat()之类的方法

解决方法

新建一个数组用于保存结果，
声明两个变量x、y用于记录遍历到数据a和b的哪个位置了
同时遍历数组a和数组b
当数组a的项小于数组b的项时，push数组a的当前项，x++
当数组b的项小于数组a的项时，push数组b的当前项，y++
当两个数相等时，同时push，x++, y++
当x>=数组a的长度并且 y>=数组b的长度时，退出循环

        var arra = new Array(10000).fill(1).map((item, index) => { return index })
        var arrb = new Array(11000).fill(1).map((item, index) => { return index })
        var x = y = 0;
        var result = [];
        while (x < arra.length || y < arrb.length) {
            if (arra[x] < arrb[y]) {
                result.push(arra[x]);
                x++;
            } else if (arra[x] > arrb[y]) {
                result.push(arrb[y]);
                y++;
            } else {
                if (arra[x] !== undefined) {
                    result.push(arra[x]);
                    x++;
                }
                if (arrb[y] !== undefined) {
                    result.push(arrb[y]);
                    y++;
                }
            }
        }

28、求数组项的最长公共前缀

现有数组 arr=["flop","flex","flow"]。求三个数组项的最长公共前缀。

解题思路

拿到数组的第一项的第一个字符。
依次和数组的其他项的第一个字符比较。
如果都相等，则第一个字符是公共前缀，将第一个字符添加到结果res中。
再去拿到数组第一项的第二个字符，依次和数组的其他项的第二个字符比较，重复这个过程。
比较过程中，只要出现不相等的情况，就立即结束比较

        function foo() {
            const arr = ["flop", "flex", "flow", "floop"];
            const first = arr[0];
            const last = arr.slice(1);
            let res = "";
            for (let i = 0; i < first.length; i++) {
                let flag = true;
                for (let j = 0; j < last.length; j++) {
                    if (first[i] !== last[j][i]) {
                        flag = false;
                        console.log(res, "最长公共前缀")
                        return
                    }
                }
                if (flag) {
                    res += first[i];
                }
            }
        }
        foo();

29、输出一个数组中出现前三个出现次数最多的项

解题思路

声明两个数组item和times
遍历数组
item保存重复出现的项
times保存重复出现的次数
遍历数组times，找到最大值对应的index，item[index]就是出现次数第一多的数组项了，，，将times[index]置为0
步骤5重复执行3次，即可得到出现次数前三多的数组项

        const repeatArr = [1, 2, 3, 4, 2, 1, 2, 3, 4, 5, 6, 4, 3, 4, 5];
        let item = [], times = [];
        for (let i = 0; i < repeatArr.length; i++) {
            const curr = repeatArr[i];
            if (!item.includes(curr)) {
                item.push(curr);
                times.push(1);
            } else {
                times[item.indexOf(curr)] += 1;
            }
        }
        for (let i = 0; i < 3; i++) {
            let index = times.indexOf(Math.max.apply(null, times));
            console.log(item[index])
            times[index] = 0;
        }

30、一个数组，只遍历一次得到重复出现次数最多的项和重复出现次数最少的项

解题思路

声明一个数组noRepeatArr保存去重后的数组项
声明一个变量arrstr，保存原数组的拼接
声明两个变量min和max记录最小值和最大值
声明两个变量minIndex和maxIndex记录最小值和最大值对应的index
遍历数组noRepeatArr
根据当前项的情况，给min、max、minIndex和maxIndex赋值
根据最大值和最小值的index 在数组noRepeatArr中找出对应的项。

const datalist = [3, 3, 2, 3, 4, 3, 1, 2, 4, 1, 6, 6, 5, 5, 4, 4, 9];
        function goo(arr) {
            const number = [...new Set(arr)];// 数组A：记录一共有几个不重复的数组项
            let min = max = 0;
            let minIndex, maxIndex;
            const arrstr = arr.join("");//原数组的拼接字符串，用于查找每项出现的次数。 
            for (let i = 0; i < number.length; i++) {
                const count = arrstr.split(number[i]).length - 1;
                if (i === 0) {
                    min = max = count;
                    minIndex = maxIndex = i
                } else {
                    if (count > max) {
                        max = count
                        maxIndex = i;
                    }
                    if (count < min) {
                        min = count
                        minIndex = i
                    }
                }
            }
            console.log(number[minIndex], number[maxIndex])
        }
        goo(datalist);

31、获取一个字符串中由连续的不相同的字符组成的最长子串

解题思路

声明两个变量temp和result，用于分别暂存当前和最终的结果
遍历字符串
temp中是否包含当前字符，不包含，直接在尾部加上该字符。。。。包含：从该字符所在位置+1 处开始截取到temp的末尾，然后尾部加上该字符
比较temp和result的长度，，当temp的长度更长时，将其赋值给result
持续遍历，直到字符串的尾部

        var str='fhdjkfdshfetyewklrhfdcxzmreyeufdjmznr';
        var str="23456ydstyjhnbvdsyukjmn4i8kjhn"
        function getLongStr(str){
            let result='',temp='';
            for(let i=0;i<str.length;i++){
                const code=str[i];
                if(temp.indexOf(code)==-1){
                    temp+=code
                }else{
                    temp=temp.substr(temp.indexOf(code)+1)+code
                }
               if(temp.length>result.length){
                   result=temp
               }
            }
            console.log(result)
        }
        getLongStr(str)

32、获取一个字符串的最长子串，子串的第一个字符和最后一个字符相同

 var str='fhdjkfdshfetyewklrhfdcxzmreyeufdjmznr';
 var str="23456ydstyjhnbvdsyukjmn4i8kjhn"
 getLongSameStr(str);
        function getLongSameStr(str){
            let tempgap=0,gap=0, start,end;
           for(let i=0;i<str.length;i++){
               console.log(str[i])
               const lastIndex=str.lastIndexOf(str[i])
               tempgap=lastIndex-i;
               if(tempgap>gap){
                   start=i;
                   end=lastIndex;
                   gap=tempgap;
               }
           }
            console.log(str.substring(start,end+1))
        }

33、将以下结构的数据进行转换，

假设有对象

const obj={
 aaaa:{
      bbbb:{
         xxxxx:{}
       },
      eee:{
         fffff:{}
    },
 }
 xxxx:{},
}

需要将这种结构的object，转换为组件a-cascader可用的list，该list的格式要求为

[
  {
    name: 'aaaa',
   value: 'aaaa',
   children:[{  
       name:'bbbb',
      value:'bbbb',
      children:[]  //        
     }]
   },
 ];

简单来说，就是不管这个object嵌套了几层，每层key，将作为数组项的name和value对应的值，每层value则会成为children，以此类推

1、解题思路

声明空数组
递归遍历当前的对象，
将key，push到数组中
若当前key值对应的value不是空对象，则从第2步开始重新执行

2、实现

function loop(obj) {
    if (!Object.keys(obj).length) {
        return;
    }
    let list = [];
    let index = 0;
    for (let key in obj) {
        list.push({
            label: key,
            value: key,
            children: [],
        });
        if (Object.keys(obj[key]).length) {
            list[index].children = loop(obj[key]);
        }
        index++;
    }
    return list;
}

const res = {
    'test': {
        '0415': {
            'v1.3.1': {
                xxxx: {},
            },
            '2345tre': {},
        },
        'p-a': {},
        'up-b': {},
    },
    'tesx': {
        '05': {
            '.3.1': {
                'xfd': {},
            },
            '245tre': {},
        },
        'p-a': {},
        'grb': {},
    },
};

const xxx = formatCaseGroup(res);
console.log(xxx, 123);

3、路径信息
若是想要得到从最上层到当前节点的路径信息，只需每次调用loop方法是带上当前的key值即可

function loop(obj, prekey) {
    if (!Object.keys(obj).length) {
        return;
    }
    let list = [];
    let index = 0;
    for (let key in obj) {
        list.push({
            label: key,
            value: key,
            path: prekey ? `${prekey}/${key}` : key,
            children: [],
        });
        if (Object.keys(obj[key]).length) {
            list[index].children = loop(obj[key], list[index].value);
        }
        index++;
    }
    return list;
}

在这里插入图片描述

34、获取一个字符串中，由连续相同的字符组成的长度最大的子串

        function maxSameCode(str) {
            if (!res) {
                return
            }
            let res = '';
            let temp = str[0];
            for (let i = 1; i < str.length; i++) {
                const chara = str[i]
                if (chara === temp[temp.length - 1]) {
                    temp += chara;
                } else {
                    if (temp.length > res.length) {
                        res = temp;
                    }
                    temp = str[i]
                }
            }
            return res
        }
        maxSameCode('retgfertretrtyrtytyuuuuuuuuffffffeedcdwwww')

35、给整数加上千位分隔符

在结账时经常看到112,111,90这样的金额，

        function fn(num) {
            if (typeof num !== 'number') {
                return
            }
            if (num > -1000 && num < 1000) {
                return num + ''
            } else if (num > 1000) {
                return insertSeparte(num)
            } else {
                return '-' + insertSeparte(Math.abs(num))
            }
        }
        function insertSeparte(num) {
            let str = num + '';
            let startIndex = str.length % 3;
            let res = str.substr(0, startIndex);
            for (let i = startIndex; i < str.length; i = i + 3) {
                res += ',' + str.substr(i, 3)
            }
            return res
        }

36、一个数组，只遍历一次，得到出现次数最多的项和出现次数最少的项

思路

1、使用两个新数组：一个数组A记录数组中的项（不重复的）、另一个数组B记录每一项出现的次数，
2、从B中得到出现初次的最大值和最小值的index
3、根据最大值和最小值的index 在数组A中找出对象的项。

完整代码如下

   var timesarr=[3,2,3,4,3,1,2,4,1,6,5,4,4];
   function times_(arr){
           var number=[...new Set(arr)];// 数组A：记录一共有几个不重复的数组项
           var arrstr=arr.join("");//原数组的拼接字符串，用于查找每项出现的次数。 
           var countarr=[];// 数组B：记录每一个不重复的项 各出现了几次
           for(var i=0;i<number.length;i++){
               var count=arrstr.split(number[i]).length-1;
               countarr.push(count);
           }
           console.log(number[countarr.indexOf(Math.max.apply(null,countarr)) ] ,"出现次数最多的")        
           console.log(number[countarr.indexOf(Math.min.apply(null,countarr))] ,"出现次数最少的")
            console.log(countarr,number,'-888888')
        }
        times_(timesarr);

胖胖我有点烦

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
一些题∩-∩

1、生成1到1000之间的质数/素数质数：除了1和它本身之外不能被其他的数整除。最小的质数是2 let result=[]; for(let i=2;i<=1000;i++){ const middle=Math.floor(i/2); let count=0; for(let j=1;j<=middle;j++){ if(i%j===0){ count++ } }
复制链接

扫一扫