ariesate / interview Goto Github PK

// 1
let arr = [
    'Allegoric Alaskans;Blithering Badgers;win',
    'Devastating Donkeys;Courageous Californians;draw',
    'Devastating Donkeys;Allegoric Alaskans;win',
    'Courageous Californians;Blithering Badgers;loss',
    'Blithering Badgers;Devastating Donkeys;loss',
    'Allegoric Alaskans;Courageous Californians;win'
]

function fn(arr) {
    let obj = {}
    arr.map(arrItem => {
        let splitArr = arrItem.split(';')
        splitArr.map((item, index) => {
            if (index != 2) {
                if (obj[item]) {
                    obj[item].MP += 1
                } else {
                    obj[item] = {
                        MP: 1,
                        W: 0,
                        D: 0,
                        L: 0,
                        P: 0
                    }
                }
            }
        })

        switch (splitArr[2]) {
            case 'win':
                obj = winCount(splitArr[0], obj)
                obj = lossCount(splitArr[1], obj)
                break;

            case 'draw':
                obj = drawCount([splitArr[0], splitArr[1]], obj)
                break;
            case 'loss':
                obj = winCount(splitArr[1], obj)
                obj = lossCount(splitArr[0], obj)
                break;

            default:
                break;
        }
    })
    objToArrAndLog(obj)
}

function winCount(win, iobj) {
    let obj = { ...iobj }
    obj[win].W += 1
    obj[win].P += 3
    return obj
}

function lossCount(loss, iobj) {
    let obj = { ...iobj }
    obj[loss].L += 1
    return obj
}

function drawCount(arr, iobj) {
    let obj = { ...iobj }
    arr.map(item => {
        obj[item].D += 1
        obj[item].P += 1
    })
    return obj
}

function objToArrAndLog(obj) {
    let arr = []
    Object.keys(obj).map(item => {
        let indexArr = []
        indexArr.push(item)
        indexArr.push(...Object.values(obj[item]))
        arr.push(indexArr)
    })
    arr = arr.sort(pSort)
    logRes(arr)
}

function pSort(x, y) {
    if (x[5] === y[5]) {
        return wordSort(x[1], y[1])
    } else {
        return y[5] - x[5]
    }
}

function wordSort(x, y) {
    let x1 = x.toUpperCase();
    let y1 = y.toUpperCase();
    if (x1 < y1) {
        return -1;
    }
    if (x1 > y2) {
        return 1;
    }
    return 0;
}

function logRes(arr) {
    let newArr = []
    console.log('Team                      | MP | W | D | L | P')
    arr.map(item => {
        let indexArr = []
        item.map((item1, index) => {
            if (index === 0) {
                indexArr.push(item1.padEnd(26))
            } else if (index === 1) {
                let newItem1 = item1
                newItem1 = String(newItem1).padStart(2)
                newItem1 = String(newItem1).padEnd(4)
                indexArr.push(newItem1)
            } else {
                let newItem1 = item1
                newItem1 = String(newItem1).padStart(2)
                newItem1 = String(newItem1).padEnd(3)
                indexArr.push(newItem1)
            }
        })
        newArr.push(indexArr)
    })
    newArr.map(item => {
        let str = JSON.stringify(item).replace(/\[|\]|"|"/g, '')
        str = str.replace(/,/g, '|')
        console.log(str)
    })
}

fn(arr)

// 4
let inputArr = [[1, 2], [1, 2], [1, 6], [2, 3], [2, 4], [3, 1], [3, 4], [4, 1], [5, 6], [5, 1], [4, 5], [5, 6], [6, 1]]

function fn(inputArr) {
    let indexObj = {}
    let sortArr = []
    inputArr.map((item, index) => {
        if (indexObj[item[0]]) {
            indexObj[item[0]] = [...indexObj[item[0]], item[1]]
        } else {
            indexObj[item[0]] = [item[1]]
        }
    })
    sortArr = groupArr(Object.keys(indexObj).sort(), [], sortArr)
    if (sortArr) {
        return getArr(indexObj, sortArr)
    } else {
        return false
    }
}

function getArr(indexObj, sortArr) {
    let arr = []
    sortArr.map((item, index) => {
        if (arr.length) {
            if (indexObj[arr[arr.length - 1][1]]) {
                if (index != sortArr.length - 1) {
                    if (indexObj[item].includes(Number(item) + 1) && indexObj[Number(item) + 1]) {
                        arr.push([Number(item), Number(item) + 1])
                    } else {
                        arr = []
                    }
                } else {
                    if (indexObj[Number(item)].includes(arr[0][0])) {
                        arr.push([Number(item), arr[0][0]])
                    } else {
                        arr = []
                    }
                }
            }
        } else {
            if (indexObj[item].includes(Number(item) + 1)) {
                arr.push([Number(item), Number(item) + 1])
            }
        }
    })
    if (arr.length) {
        return arr
    } else {
        return false
    }
}

function groupArr(arr, sarr, sortArr) {
    let newarr = sarr || []
    if (newarr.length) {
        if (Number(newarr[newarr.length - 1]) + 1 === Number(arr[0])) {
            newarr.push(arr.shift())
            if (arr.length === 0) {
                return newarr
            }
        } else {
            return false
        }
    } else {
        newarr.push(arr.shift())
    }
    if (arr.length > 0) {
        groupArr(arr, newarr, sortArr)
    }
    return newarr
}

// 5
// 1
let res = fn(inputArr)
console.log('res', res);

class Bus {
    constructor() {
        this.task = {}
    }
    listen(name, cb) {
        this.task[name] = cb
    }
    listenMore(name, cb) {
        if (name.length != cb.length) {
            return new Error('多重监听参数如([],[])且[]长度应一致')
        } else {
            name.map((item, index) => {
                this.task[item] = cb[index]
            })
        }
    }
    trigger(...name) {
        name && name.map(item => {
            if (this.task[item]) {
                this.task[item]()
                this.unListen(item)
            } else {
                console.log(`${item}该函数未监听`);
                // throw new Error(`${item}该函数未监听`)
            }
        })
    }
    unListen(name) {
        this.task[name] = null
    }
}


const bus = new Bus()
bus.listen('testEvent', (...argv) => {
    console.log('event callback')
})
bus.trigger('testEvent', 1, 2)
// TODO:2、3