算法小积累

1.求 a, b 最小公倍数

最小公倍数 = （ a * b ) / 最大公约数

最大公约数：

function maxNum (a, b) { // 求最大公约数
    var result = i
    for (var i = 1; i < a && i < b; i++) {
        if (a % i === 0 && b % i === 0) {
            result = i
        }
    }
    return result
}        

function minCount () { // 求最小公倍数
    var res = (a * b) / maxNum(a, b)
    return res
}

 

2.约瑟夫问题

约瑟夫(Joseph)问题的一种描述是:编号为1,2,..., n的n个人按顺时针方向围坐一圈, 每人持有一个密码(正整数)。一开始选任一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将它的密码作为新的m值。试设计一个程序求出出列顺序。

测试数据：m的初值为20；n=7，7个人的密码依次为：3，1，7，2，4，8，4（正确的出列顺序应为6，1，4，7，2，3，5） 

// var arr = readline().split('');
var arr = [{ 1: 3 }, { 2: 1 }, { 3: 7 }, { 4: 2 }, { 5: 4 }, { 6: 8 }, { 7: 4 }];
var m = 20,n = 0
var len = arr.length
for (var i = 0; i < len; i++) {
    var index = (n + m - 1) % arr.length
    obj = arr[index]
    for (var nn in obj) {
        m = obj[nn]
        console.log(nn)
        console.log(obj[nn], 'key')
    }
    arr.splice(index, 1)
    n = index % arr.length
}

 

3.promise实现

Promise 是抽象的异步处理对象，以及对其进行各种操作的组件。可以把 Promise 理解成一个 容器，里面装着将来才会结束的一个事件的结果，这个事件通常是一个异步操作。

// promise实现
function promiseAll(promises) {
    return new Promise((resolve, reject) => {
        var resultCounts = 0
        var result = []
        for(var i = 0; i < promises.length; i++) {
            promises[i].then(res => {
                resultCounts++
                result[i] = res
                if(resultCounts === promises.length) {
                    return resolve(result)
                }
            }).catch(err => {
                reject(err)
            })
        }
    })
}

var p1 = new Promise((resolve, reject) => {
    resolve('p1')
})
var p2 = new Promise((resolve, reject) => {
    resolve('p2')
})
var p3 = new Promise((resolve, reject) => {
    reject('error')
})
promiseAll([p1,p2,p3]).then(result => {
    console.log(result)
}).catch(error => {
    console.log(error)
})