Promotion progression logic

Question

i have list of items in cart(assume each letter is an item)

cart list = a,s,d,f,a,s,d,f,a

here is the promotion

buy 1 a and get 2 d Free of Charge(in the below logic 1 is srcNum and 2 is tarNum)

the logic should be progressive.(for each a 2d should be free). for the above input o/p should be d,d

i made some thing like below. but not working any help appreciated

Iterator tempIterator = tempList.iterator();

    boolean targetCheck = false;
    int check=0;
    boolean runCompleted = false;
    while (!runCompleted && tempIterator.hasNext()){
        String itemCode = (String) tempIterator.next();
        if(!targetCheck && targetItemsList.contains(itemCode) && check < tarNum){
            tempIterator.remove();
            check++;
        }
        else if (check >= tarNum && targetCheck == false) {
            check = 0;
            targetCheck = true;
        }
        else if (check < srcNum && targetCheck == true) {
            tempIterator.remove();
            Integer discountQuantity = discountedItems.get(itemCode);
            if(null==discountQuantity)  {
                discountQuantity = 1;
            }else {
                discountQuantity++;
            }
            discountedItems.put(itemCode,discountQuantity);
            check++;
        }
        else if (check >= srcNum && targetCheck == true) {
            check = 0;
            targetCheck = false;
        }
        if(tempList.size()==0){
            runCompleted = true;
        }else{
            tempIterator = tempIterator = tempList.iterator();
        }

Answer 1

Your discount must be stored: item a has 2 d free. Since java 9 you can use the record class.

record Discount(int itemCode, int free) {};
Map<Integer, Discount> itemCodeToDiscountMap = new HashMap<>();

This becomes a bit more complex if 2 a 1 d free or even 2 a 1 a free. But not unduly.

You have a chaotic cart, something like:

List<Item> cartList = new ArrayList<>();

This is best kept in a map of item code to quantity.

Map<Integer, Integer> itemCodeToQuantityMap = new HashMap<>();

At the end of your evaluation you will have:

Map<Integer, Integer> itemsToPay = new HashSet<>();
Map<Integer, Integer> itemsFree = new HashSet<>();
Map<Integer, Integer> itemsCouldTakeFree = new HashSet<>();

So [a, a, b, d, d, d] with 1a=2d free:

• itemsToPay = [a -> 2, b -> 1]
• itemsFree = [d -> 3]
• itemsCouldTakeFree = [d -> 1] "You can fetch 1 d free"

The first step, simplifying the cart data:

List<Item> cartList = new ArrayList<>();
...
Map<Integer, Integer> itemCodeToQuantityMap = new HashMap<>();
for (Item item: cartList) {
    Item oldItem = itemCodeToQuantityMap.get(item.itemCode);
    ...
    itemCodeToQuantityMap.get(item.itemCode, ...);
}

And then

itemsToPay.putAll(itemCodeToQuantityMap);
for (Map.Entry<Integer, Integer> entry: itemCodeToQuantityMap.entrySet()) {
    int itemCode = entry.getKey();
    int quantity = entry.getValue();
    Discount discount = itemCodeToDiscountMap.get(itemCode);
    ...
}

First making a copy of itemCodeToQuantityMap into itemsToPay means you need not alter itemCodeToQuantityMap but can discount in / subtract from itemsToPay.

As this reeks of home work, I leave it at that. Just the tips:

• Use data structures easying the work; here having the quantity of every item. So one needs a Map.