限制并发

[LiuL0703]

Promise实现一个 并发限制的方法 限制每次最多同时发送n个请求

async function pMap (iterable, mapper, concurrency) {
    return new Promise((resolve, reject_)=>{
        const result = []
        const iterator = iterable[Symbol.iterator]()

        let currentIndex = 0
        let resolvingCount = 0
        let isRejected = false
        let isIterableDone = false



        const reject = (reason) => {
            isRejected = true
            reject(reason)
        }


        const next = () => {
            if (isRejected) {
                return 
            }
            const nextItem = iterator.next()
            const index = currentIndex

            currentIndex++

            if (nextItem.done) {
                isIterableDone = true
                if (resolvingCount === 0) {
                    resolve(result)   
                }
                return
            }

            resolvingCount++

            (async()=>{
                try {
                    const element = nextItem.value
                    if (isRejected) {
                        return
                    }
                    const value = await mapper(element, index)
                    result[index] = value
                    resolvingCount--
                    next()
                } catch (error) {
                    reject(error)
                }
            })()
        }



        for(let index = 0; index < concurrency; index++) {
            try {
                next()
            } catch(error) {
                reject(error)
                break
            }
            if (isIterableDone || isRejected) {
                break
            }
        }

    })
}


const mapper = (time) => {
    return new Promise((resolve, reject) => {
      setTimeout(() => {
          console.log(time)
          resolve(time)
      }, time);
    });
}


pMap([1000, 3000, 2000, 4000], mapper, 2)

[LiuL0703]

n 个小孩分 k个饼干 列出所有可能性，饼干不能有剩余

const assignCookies = (children, cookies) => {
    const result = []

    const backetracking = (curIndex, restCook, allCookies,path) => {
        if (curIndex === children+1) {
            if (path.reduce((acc, cur) => acc + cur, 0) === cookies){
                result.push(path.slice())
            }
            return
        }
        path.push(restCook)
        for (let i = allCookies-restCook; i >= 0; i--) {
           backetracking(curIndex + 1, i, allCookies-restCook ,path.slice())
        }
    }

    for (let i = cookies; i >= 0; i--) {
        backetracking(1, i, cookies,[])
    }

    return result
}

assignCookies(3, 2)