摘要：原來(lái)的需求是這樣的，用戶生成了元訂單，需要元的發(fā)票去抵消，發(fā)票數(shù)和訂單數(shù)不受限制，將問(wèn)題擬物化，訂單可以想象成杯子，發(fā)票可以想象成水，現(xiàn)在要把水分配到每個(gè)杯子中去我們先記錄每個(gè)杯子的起始值和結(jié)束值，還有當(dāng)前值，起始值當(dāng)前杯子的起始值加上上一

原來(lái)的需求是這樣的，用戶生成了400元訂單，需要400元的發(fā)票去抵消，發(fā)票數(shù)和訂單數(shù)不受限制，

將問(wèn)題擬物化，訂單可以想象成杯子，發(fā)票可以想象成水，現(xiàn)在要把水分配到每個(gè)杯子中去
我們先記錄每個(gè)杯子的起始值和結(jié)束值，還有當(dāng)前值，起始值（start）=當(dāng)前杯子的起始值加上上一個(gè)杯子的結(jié)束值，結(jié)束值（end）即起始值加上杯子的容量，當(dāng)前值（index）即當(dāng)前杯子中的水，如果大于杯子的容量則倒下一個(gè)杯子，依次循環(huán)，所以其實(shí)整個(gè)倒水可以看做一個(gè)大杯子，按階段倒水，每次記錄倒水的index（即當(dāng)前（或者當(dāng)次）杯子中的水即可）

現(xiàn)在假設(shè)a杯50L， b杯20L
假如第一次倒， a[0, 50]杯子倒?jié)M，剩余20；index = 50 , start = 0 , end = 50;
第二次倒b杯[50, 70]， 首先拿上一下剩余的20L， 剛好倒?jié)M，index = 20; start = 50 ,end = 70
依次類推

話不多說(shuō)，上代碼

export function getItemDistribution(a, b, waterKey, cupKey, policyId) {

    class ItemDistribution { 
        cupList = [];
        result = [];

        constructor(list, maps) {
            this.waterKey = waterKey;
            this.cupKey = cupKey;
            this.policyId = policyId;
            this.sort(list, maps);
            this.init(list);
        }

        sort(list, maps) {
            let {waterKey, cupKey} = this;
            if (waterKey) {
                list = list.sort((a, b) => a[waterKey] - b[waterKey]);
            } else {
                list = list.sort((a, b) => a - b);
            }
            if (cupKey) {
                maps = maps.sort((a, b) => a[cupKey] - b[cupKey]);
            } else {
                maps = maps.sort((a, b) => a - b);
            }
            this.list = list;
            this.maps = maps;
            return {list, maps}
        }

        init(list) {
            if (list == null || list.length <= 0) {
                return;
            }
            let start = 0, end = 0, index = 0;
            let {waterKey} = this;
            list.forEach((item, id) => {
                if (!waterKey) {
                    this.result[id] = [];
                }
                let water = waterKey ? item[waterKey] : item;
                end = start + Number(water);
                this.entry({start, index, end});
                start = end;
            });
            this.dispatchMaps();
        }

        entry({start, index, end}) {
            index = start;
            this.cupList.push({start, end, index})
        }

        dispatchMaps() {
            function isEmpty(o) {
                switch (JSON.stringify(o)) {
                    case "null":
                    case undefined:
                        return true;
                    case "[]":
                        return true;
                }
                return false;
            }

            let {maps = [], cupList, cupKey} = this;
            if (isEmpty(cupList) || isEmpty(maps)) return false;
            maps.forEach((item, id) => {
                let cup = cupKey ? item[cupKey] : item;
                this.dispatchCup({item: cup, id});
            });
        }

        getCup() {
            function isEqual(a, b) {
                return String(a.toFixed(2)) !== String(b.toFixed(2));
            }

            let {cupList} = this;
            for (let i = 0; i < cupList.length; i++) {
                let item = cupList[i];
                if (isEqual(item.end, item.index)) {
                    return {cup: item, cupIndex: i};
                }
            }
            return {};
        }

        dispatchCup({item, id}) {
            let {cup, cupIndex} = this.getCup();
            if (!cup) return false;
            let {index, end} = cup;
            let remain = end - index;
            let {waterKey, list, policyId, maps} = this;
            if (remain > item) {
                cup.index = cup.index + item;
                waterKey ? this.result.push({
                    ...list[cupIndex],
                    [waterKey]: item,
                    [policyId]: maps[id][policyId]
                }) : this.result[id].push(item);
                return false;
            } else {
                cup.index = cup.end;
                waterKey ? this.result.push({
                    ...list[cupIndex],
                    [waterKey]: remain,
                    [policyId]: maps[id][policyId]
                }) : this.result[id].push(remain);
                item -= remain;
                this.dispatchCup({item, id})
            }
        }
    }

    return new ItemDistribution(a, b);
}