遇到过的JS笔试编程题(持续更新)

斐波那契

 //第一种方法递归
 const fib = function(n){
     if(n<2){
     return n
     }else{
      return fib(n-1)+fib(n-2)
     }
 }
 //第二种方法动态规划
 const fib = function(n){
     if(n<2){
        return n
    }
     let q=0,p=0,r=1;
     for(let i=2;i<=n;++i){
         q=p;
         p=r;
         r=q+p;
     }
     return r
 }

最长公共前缀

    var longestCommonPrefix = function(strs) {
    //初始化第一个字符串为res对照租
    let res =strs[0];
    for(let i=1;i<strs.length;i++){
        let j=0;
        for(;j<res.length && strs[i].length;j++){
            //判断到什么位置字符串才不相等
            if(res[j]!=strs[i][j]){
                break;
            }
        }
        //此时j为最大公共前缀的下标
        res=res.substr(0,j)
        if(res === '') return ''
    }
    return res;
};

两个数组的交集

var intersection = function (nums1, nums2) {
    let res = [];
    //nums2中的元素大于nums1
    if (nums1.length < nums2.length) {
        for (let i = 0; i < nums1.length; i++) {
            if (nums2.indexOf(nums1[i]) != -1 && res.indexOf(nums1[i]) == -1) {
                //如果nums2中包含nums1中的元素，且res中不含又nums1中的元素
                res.push(nums1[i]);
            }
        }
    } else {
        //nums1中的元素大于nums2
        for (let i = 0; i < nums1.length; i++) {
            if (nums1.indexOf(nums2[i]) != -1 && res.indexOf(nums2[i]) == -1) {
                //如果nums2中包含nums1中的元素，且res中不含又nums1中的元素
                res.push(nums2[i]);
            }
        }
    }
    return res
};

中序遍历二叉树

var inorderTraversal = function(root) {
   let res=[];
   //中序遍历为先遍历左节点，再压根节点进res，再遍历右节点，实现递归
   const inorder =(root)=>{
    if (!root) {
        return;
    }
    inorder(root.left);
    res.push(root.val);
    inorder(root.right)
   }
   inorder(root)
   return res
};

最后出现的字符串

function lastUniqueChar( str ) {
    // write code here
    if(!str) return ''
    let res=[];
    for(let i=0;i<str.length;i++){
        if(str.indexOf(str[i])==str.lastIndexOf(str[i]) ){
            res.push(str[i])
        }
    }
    if(res.length === 0){
        return ''
    }else{
        return res[res.length-1]
    }
}

数组扁平化

const data = [{
        currentName: "北京市",
        children: [{
            currentName: "北京市",
            children: [{
                    currentName: "东城区",
                    children: [],
                },
                {
                    currentName: "西城区",
                    children: [],
                },
            ],
        }, ],
    },
    {
        currentName: "天津市",

        children: [{
            currentName: "天津市",

            children: [{
                    currentName: "和平区",
                    children: [],
                },
                {
                    currentName: "河东区",
                    children: [],
                },
            ],
        }, ],
    },
];
//将以上的的数组拍平
function flatTree(data){
    let res =[]
    const fn=(item,str='')=>{
        //解构赋值
        const{
            currentName,
            children
        }=item
        let temp = `${str}${currentName}`
        if(children && children.length>0){
            children.forEach((child)=>fn(child,temp))
        }else{
            res.push(temp)
        }
    }
    data.forEach((item)=>fn(item))
    return res
}

扁平化数组转Tree

var menu_list = [{
    id: '1',
    menu_name: '设置',
    menu_url: 'setting',
    parent_id: 0
}, {
    id: '1-1',
    menu_name: '权限设置',
    menu_url: 'setting.permission',
    parent_id: '1'
}, {
    id: '1-1-1',
    menu_name: '用户管理列表',
    menu_url: 'setting.permission.user_list',
    parent_id: '1-1'
}, {
    id: '1-1-2',
    menu_name: '用户管理新增',
    menu_url: 'setting.permission.user_add',
    parent_id: '1-1'
}, {
    id: '1-1-3',
    menu_name: '角色管理列表',
    menu_url: 'setting.permission.role_list',
    parent_id: '1-1'
}, {
    id: '1-2',
    menu_name: '菜单设置',
    menu_url: 'setting.menu',
    parent_id: '1'
}, {
    id: '1-2-1',
    menu_name: '菜单列表',
    menu_url: 'setting.menu.menu_list',
    parent_id: '1-2'
}, {
    id: '1-2-2',
    menu_name: '菜单添加',
    menu_url: 'setting.menu.menu_add',
    parent_id: '1-2'
}, {
    id: '2',
    menu_name: '订单',
    menu_url: 'order',
    parent_id: 0
}, {
    id: '2-1',
    menu_name: '报单审核',
    menu_url: 'order.orderreview',
    parent_id: '2'
}, {
    id: '2-2',
    menu_name: '退款管理',
    menu_url: 'order.refundmanagement',
    parent_id: '2'
}]
function buildTree(arr) {
    let temp=[];
    let res=[];
   for(let i in arr){
    temp[arr[i].id]=arr[i]
   }
   for(let i in temp){
       if(temp[i].parent_id){
        if(!temp[temp[i].parent_id].children){
            temp[temp[i].parent_id].children = new Object;
        }
        temp[temp[i].parent_id].children[temp[i].id] = temp[i]
       }else{
           res.push(temp[i])
       }
   }
   return res
}

拍平多维数组

let arr=[1,[2,[3,[4,[5]]]]];
//递归
function flatArr(arr){
    let res=[];
    arr.forEach((item)=>{
        if(Array.isArray(item)){
            return res=res.concat(flatArr(item))
        }else{
            res.push(item)
        }
    })
    return res
}
//使用拓展运算符+concat
function flatArr(arr){
    while(arr.some(item=>Array.isArray(item))){
        arr=[].concat(...arr)
    }
    return arr
}
//使用es6+新语法Array.prototype.flat()
function flatArr(arr){
    return arr.flat(Infinity)
}

自定义字符串排序

/**
 * @param {string} order
 * @param {string} s
 * @return {string}
 */
 //先转为数组，然后替换目标字符为数字，数字字符分两个数组，给数字的数组排序，然后把两个数组拼起来，把数字替换回目标字符
var customSortString = function(order, s) {
    s=s.split('')
	var tmp=s
	for(let i in order){
	    for(let j in s){
			if(s[j]==order[i]){
				s[j]=parseInt(i)
			}
		}
	}
	tmp=s.filter((value,index,array)=>{return ((typeof value )=='number')}).sort((a,b)=>a-b)
	s=s.filter((value,index,array)=>{return ((typeof value )!='number')})
	s=tmp.concat(s)
    for(let i in order){
        for(let j in s){
			if(s[j]==i){
				s[j]=order[i]
			}
		}
    }
	s=s.join('')
    return s
};