Résoudre le problème de l'allocation de montants pour plusieurs commandes et plusieurs modes de paiement en Java

Il s'agit d'une question d'entretien. La description du problème est la suivante : plusieurs commandes commerciales correspondent à un seul ordre de paiement, et un paiement combiné est utilisé lors du paiement. Ensuite comment calculer le mode de paiement et le montant attribué à chaque commande.

Un total de trois combinaisons de modes de paiement A, B et C représentent respectivement 100, 100 et 80.

Un total de deux commandes : 1 commande d'un montant de 80, 2 commandes d'un montant de 200 .

Après allocation, 4 commandes et données avec différents modes de paiement sont générées.

Dessinez une image pour la rendre plus claire :

Problème abstrait :

Nous avons constaté que la figure 1 et la figure 2 se chevauchaient et peu de temps après Figure 3 Attribuez les résultats.

Mais le code ne semble pas si simple à utiliser.

J'ai à nouveau matérialisé le problème. La combinaison de modes de paiement peut être imaginée comme différents types de tasses, et la combinaison de commandes est composée de différents types de vins. Chaque compte à rebours compte les données pour une combinaison de commande et de mode de paiement.

Première fois : le vin n°1 a commencé à arriver, mais il n'était même pas plein dans la tasse A, donc tout a été versé. Les données sont 1+A+80

La deuxième fois : versez le vin n°2 dans A et les 20 pluies restantes sont pleines. Les données sont 2+A+20

La troisième fois : versez le vin n°2 dans la tasse B, remplissez-la de 100, et il en reste 80 au vin n°2. Les données sont 2+B+100

La quatrième fois : le vin n°2 a été versé dans la tasse C, et elle était presque pleine. Les données sont 2+C+80

Nous constatons que ces quatre opérations doivent parcourir les données de la combinaison de commandes et occuper à leur tour les données du montant du paiement restant. Et les temps 2, 3 et 4 sont un processus de code itératif.

Si vous avez le temps, vous pouvez l'implémenter vous-même en utilisant le code que vous connaissez. D'ailleurs, je rassemblerai également diverses méthodes et idées d'implémentation.

Une implémentation est donc la suivante :

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);
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!