Lösung des Problems der Zuweisung von Beträgen für mehrere Bestellungen und mehrere Zahlungsmethoden in Java

Es handelt sich um eine Interviewfrage. Die Problembeschreibung lautet wie folgt: Mehrere Geschäftsaufträge entsprechen einem Zahlungsauftrag, und bei der Zahlung wird eine kombinierte Zahlung verwendet. Anschließend erfahren Sie, wie Sie die Zahlungsmethode und den Betrag berechnen, der jeder Bestellung zugeordnet ist.

Insgesamt drei Zahlungsmethodenkombinationen A, B und C machen jeweils 100, 100 und 80 aus.

Insgesamt zwei Bestellungen: 1 Bestellbetrag 80, 2 Bestellbetrag 200 .

Nach der Zuordnung werden 4 Bestellungen und Daten mit unterschiedlichen Zahlungsarten generiert.

Zeichnen Sie ein Bild, um es klarer zu machen:

Abstraktes Problem:

Wir haben festgestellt, dass sich Abbildung 1 und Abbildung 2 überlappten und kurz darauf Abbildung 3 Ordnen Sie die Ergebnisse zu.

Aber der Code scheint nicht so einfach zu bedienen zu sein.

Ich habe das Problem wieder verwirklicht. Die Kombination der Zahlungsmethoden kann man sich als verschiedene Arten von Tassen vorstellen, und die Bestellkombination sind verschiedene Arten von Wein. Jetzt muss ich den Wein in mein Leben bringen. Bei jedem Countdown werden Daten für eine Kombination aus Bestellung und Zahlungsmethode gezählt.

Erstes Mal: ​​Wein Nr. 1 kam an, aber der Becher A war noch nicht einmal voll, also wurde alles ausgegossen. Die Daten sind 1+A+80

Das zweite Mal: ​​Gießen Sie Wein Nr. 2 in A und die restlichen 20 Regen sind voll. Die Daten sind 2+A+20

Das dritte Mal: ​​Gießen Sie Wein Nr. 2 in Becher B, füllen Sie ihn mit 100, und Wein Nr. 2 hat noch 80 übrig. Die Daten sind 2+B+100

Das vierte Mal: ​​Wein Nr. 2 wurde in Tasse C gegossen, und sie war fast voll. Die Daten sind 2+C+80

Wir stellen fest, dass diese vier Vorgänge dazu dienen, die Daten der Bestellkombination zu durchlaufen und nacheinander die Daten des verbleibenden Zahlungsbetrags zu belegen. Und die Zeiten 2, 3 und 4 sind ein iterativer Codeprozess.

Wenn Sie Zeit haben, können Sie es auch selbst mit dem Ihnen vertrauten Code implementieren. Ich werde übrigens auch verschiedene Implementierungsmethoden und Ideen sammeln.

Eine Implementierung sieht also wie folgt aus:

public class ItemDistribution {

    private List<Entry> cupList = new ArrayList<>();

    /**
     * 初始化
     * @param list
     */
    public ItemDistribution(List<Item> list) {
        if(list == null || list.size()<=0){
            return;
        }
        Integer start = 0;
        Integer end = 0;
        for(Item item : list){
            end = start + item.amount;
            Entry entry = new Entry(start, end, item.payMethod);
            start = end;
            cupList.add(entry);
        }
    }

    /**
     * 分配
     * @param orderIdAmountMap
     * @return
     */
    public List<Item> getOrderInfoItemList(Map<Integer, Integer> orderIdAmountMap){
        if(cupList == null){
            return null;
        }
        List<Entry> cupTransferList = cupList;
        List<Item> returnItems = new ArrayList<>();
        for (Map.Entry<Integer, Integer> orderIdAmountEntry : orderIdAmountMap.entrySet()) {
            Integer orderId = orderIdAmountEntry.getKey();
            Integer orderAmount = orderIdAmountEntry.getValue();
            buildItem(orderId, orderAmount, cupTransferList, returnItems);
        }
        return returnItems;
    }

    /**
     * 单个cup分配
     * @param orderId
     * @param orderAmount
     * @param cupList
     * @param returnItems
     */
    private void buildItem(Integer orderId, Integer orderAmount, List<Entry> cupList, List<Item> returnItems) {
        if(IntegerUtil.isZero(orderAmount) || orderId == null){
            return;
        }

        Entry cup = getLatestCup(cupList);
        if(cup == null){
            return;
        }
        Integer remain = cup.end - cup.index;
        Item item = null;
        if(remain > orderAmount){
            cup.index = cup.start + orderAmount;
            item = new Item(orderId, orderAmount, cup.payMethod);
            returnItems.add(item);
            return;
        }else{
            cup.index = cup.end;
            item = new Item(orderId, remain, cup.payMethod);
            returnItems.add(item);
            orderAmount = orderAmount - remain;
        }

        buildItem(orderId, orderAmount, cupList, returnItems);
    }

    /**
     * 获得可用的cup
     * @param cupTransferList
     * @return
     */
    private Entry getLatestCup(List<Entry> cupTransferList){
        for(Entry cup : cupTransferList){
            if(!IntegerUtil.isEquals(cup.index, cup.end)){
                return cup;
            }
        }
        return null;
    }

    public class Entry{
        private Integer start;
        private Integer end;
        private Integer index = 0;
        private Integer payMethod;

        public Entry(Integer start, Integer end, Integer payMethod) {
            this.start = start;
            this.index = start;
            this.end = end;
            this.payMethod = payMethod;
        }
    }


    public static void main(String[] args) {
        List<Item> list = new ArrayList<Item>();
        Item OrderPayInfoItem1 = new Item(100,1);
        Item OrderPayInfoItem2 = new Item(100,2);
        Item OrderPayInfoItem3 = new Item(80,3);
        list.add(OrderPayInfoItem1);
        list.add(OrderPayInfoItem2);
        list.add(OrderPayInfoItem3);
        ItemDistribution itemDistribution = new ItemDistribution(list);

        Map map = new HashMap<>();
        map.put(1001, 80);
        map.put(1002, 200);
        List<Item> returnList = itemDistribution.getOrderInfoItemList(map);
    }
}

Das obige ist der detaillierte Inhalt vonLösung des Problems der Zuweisung von Beträgen für mehrere Bestellungen und mehrere Zahlungsmethoden in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!