笔试题

第一题 用正则解析 url 的参数

// 入参格式参考：
    const sourceUrl = "https://www.taobao.com?a=1&b=2&c=3&d#name";
    // 出参格式参考：
    const params = {
        a: "1",
        b: "2",
        c: "3",
        d: null
    };
    
    // 答案
    function queryParse(url) {
        /**
         * 此处写代码逻辑
         */
        let params = url.match(/(?<=\?).*?(?=#)/)[0];
        if (!params) return {};
        let flags = params.split('&');
        let query = {};
        for (let i = 0; i < flags.length; i++) {
            let val = flags[i];
            if (val.indexOf('=') !== -1) {
                let arr = val.split('=');
                let attr = arr[0];
                let v = arr[1];
                query[attr] = v;
            } else {
                query[val] = null;
            }
        }
        return query;
    }

第二题 判断一个链路是否对称闭环

// input: 1->2
// ouput: false

// input 1->2->3->2->1
// ouput: true

// 答案
 function isSymmetricalClosed(path) {
        /**
         * 此处写代码逻辑
         */
        if (!path.length) return false;
        if (path.length === 1) return true;
        // 用栈
        let stack = path.split('->');
        let r = false;
        while (stack.length > 1) {
            if (stack.shift() === stack.pop()) {
                r = true;
            } else {
                r = false;
                break;
            }
        }
        return r;
    }

第三题 顺序打印一个列表，两次打印间需要有时间间隔

// 入参格式参考：list = [1, 2, 3, 4]  delay = 5
// 控制台输出情况：
// > 1
// （过了 5 秒）
// > 2
// （过了 5 秒）
// > 3
// （过了 5 秒）
// > 4

// 答案
function printList(list, delay) {
        /**
         * 此处写代码逻辑
         * 考虑可以用setInterval来做延迟输出，但第一次要直接输出
         * 也可以考虑setTimeout,输出后一项后检查数组是否还有值，可以通过递归，或者循环里delay时间增加
         */
        let timer = void 0;
        if (!list.length) return;
        // 第一次
        console.log(list.shift());
        // 第一次之后
        timer = setInterval(function () {
            let v = list.shift();
            if (v !== undefined) {
                console.log(v);
            } else {
                clearInterval(timer);
            }
        }, delay)
    }

第四题 从一个树状数据结构中，找出值最大的一个节点

// 入参格式参考：
    const sourceTree = {
        id: "i1",
        value: 17,
        left: {
            id: "i3",
            value: 83,
            left: {
                id: "i4",
                value: 101
            },
            right: {
                id: "i9",
                value: 22
            }
        },
        right: {
            id: "i11",
            value: 26
        }
    };
    // 出参格式参考：
    const maxNode = {
        id: "i4",
        value: 101
    };
    
    // 答案
    function findMaxNode(tree) {
        /**
         * 此处写代码逻辑
         */
        if (!tree) return null;
        if (!findMaxNode.obj) {
            findMaxNode.obj = {
                id: tree.id,
                value: tree.value
            }
        }
        let left = tree.left;
        let right = tree.right;
        if (left) {
            if (left.value > findMaxNode.obj.value) {
                findMaxNode.obj = {
                    id: left.id,
                    value: left.value
                }
            }
            findMaxNode(left);
        }
        if (right) {
            if (right.value > findMaxNode.obj.value) {
                findMaxNode.obj = {
                    id: right.id,
                    value: right.value
                }
            }
            findMaxNode(right);
        }
        return findMaxNode.obj;
    }

第五题 实现一个日程安排函数，可以不断地登记行程安排，但不允许时间上出现三重重叠

// 实现一个日程安排函数，可以不断地登记行程安排，但不允许时间上出现三重重叠
// *三重重叠的含义为：有某个日期，同时被三次登记覆盖到
// *不考虑不同月份，并且假定每个月都是 31 天

// 答案
 class Calendar {
        /**
         * 此处写代码逻辑
         */
        constructor() {
            this.days = [];
            // new的时候先初始化days
            for (let i = 0; i < 31; i++) {
                this.days.push({
                    id: i +1,
                    type: 0
                })
            }
        }
        book(start, end) {
            if (end < start || end > 31 || start < 1) throw new Error('输入有误！');
            for (let i = start; i <= end; i++) {
                if (this.days[i - 1].type === 2) throw new Error(i + '号已不能订阅（不能有三次重叠！）')
                this.days[i - 1].type += 1;
            }
        }
    }

以上运行均无问题~

...