Coin change logic

Question

Im stuck at this problem about the change of a vending machine (using 10ct, 20 ct, 50ct, 100ct and 200ct-coins.)

So lets say coffee costs 40cts. The user throws in 2€ (labeled 200cts).

Now im supposed to figure out how the change of 160cts is given back to the user. There are 2 conditions: A) Taking the shortest combination, but B) only if the register has enough coins to hand out said combination .

So in my example, the shortest combination is 100cts + 50cts + 10cts. But if, lets say, there are no 10ct coins left in the register, the prefered combination should be 100ct + 20ct + 20ct + 20ct.

public void coinChange (int change) {
    
    int TwoEuroCount = 0, OneEuroCount= 0, FiftyCentsCount = 0, TwentyCentsCount = 0, TenCentsCount = 0;
    
    while (change > 0) {
            
            TwoEuroCount = change / 200;

            if(register.availableTwoEuros(TwoEuroCount) == true) {
                register.withdrawTwoEuros(TwoEuroCount);
                change = change - 200 * TwoEuroCount;

            //the method .availableTwoEuros returns true if AmountOfTwoEuros - TwoEuroCount >= 0
            }
            
            OneEuroCount = change / 100;

            if(register.availableOneEuro(OneEuroCount) == true) {
                register.withdrawOneEuro(OneEuroCount);
                change = change - 100 * OneEuroCount;
            }
            
            FiftyCentsCount = change / 50;

            if(register.availableFiftyCents(FiftyCentsCount) == true) {
                register.withdrawFiftyCents(FiftyCentsCount);
                change = change - 50 * FiftyCentsCount;
            }
            
            TwentyCentsCount = change / 20;

            if (register.availableTwentyCents(TwentyCentsCount) == true) {
                register.withdrawTwentyCents(TwentyCentsCount);
                change = change - 20 * TwentyCentsCount;
            }
            
            TenCentsCount = change / 10;

            if(register.availableTenCents(TenCentsCount) == true) {
                register.withdrawTenCents(TenCentsCount);
                change = change - 10 * TenCentsCount;
            }       
    }   
}

This works perfectly for finding the shortest combination if there are enough coins. But if i start with AmountTenCents = 0, the method will just take 1 Euro and 50cts and leave it at that.

what is the lowest cost of an item from the vending machine? — smac89, Feb 06 '21 at 18:04
40cts is the lowest cost. But we're asked to keep it universal and not use number-specified logic. (Unfortunately) — QWERTYZ, Feb 06 '21 at 18:07
I guess a better question to ask is: _Are the cost of all the items in the vending machine a multiple of the lowest denomination of change you can give?_ i.e. if the lowest denomination is 10cts, are all the items in the vending machine multiples of 10cts? The reason I ask is just to get a sense of the level of difficulty of the problem — smac89, Feb 06 '21 at 18:30
Yes, all prices are multiples of 10. 40ct, 50ct, 60ct and 70ct to be precise. — QWERTYZ, Feb 06 '21 at 18:39

Peter Dongan · Answer 1 · 2021-02-06T19:04:39.803

1

Implement a method in your register class:

register.GetSmallestChangeAvailable()

that says what the smallest change available is.

Check that before subtracting the coins. You also should handle cases where it has one coin left but would otherwise use two - for example if it had one 20c coin and was trying to provide 40c of change. For example instead of

        if(register.availableFiftyCents(FiftyCentsCount) == true) {
            register.withdrawFiftyCents(FiftyCentsCount);
            change = change - 50 * FiftyCentsCount;
        }

Use

for (int i = 0; i< fiftyCentCount; i++)
{
   if ( (change - 50 == 0 || change - 50 >= register.GetSmallestChangeAvailable() && register.availableFiftCents(1))
   {
      register.withdrawFiftyCents(FiftyCentsCount);
      change = change - 50 * FiftyCentsCount;
   }
}

It would also be better to extract the duplicate code into a single method.

Edit: The options for how to implement GetSmallestAvailableChange() depend on how the Register class is implemented. However the following would work, based on what you've mentioned here:

if (AvailableTenCents(1))
    return 10;
if (AvailableTwentyCents(1))
    return 20;
 if (AvailableFiftyCents(1))
    return 50;

etc..

edited Feb 06 '21 at 19:04

answered Feb 06 '21 at 18:00

Peter Dongan

1,762
12
17

How could the register.GetSmallestChangeAvailable() be realized? Or better asked: How can i deteremine whats the smallest available change? – QWERTYZ Feb 06 '21 at 18:54
Updated answer with example of how to do that – Peter Dongan Feb 06 '21 at 19:05
This wouldn't always work though. For example if you had one fifty cent coin and four twenty cent coins and needed to give 80c. A recursive approach might be better. Or check for possible dead ends with conditional logic. On my phone now but might update answer later. – Peter Dongan Feb 06 '21 at 19:12
1

Yeah, since im not that experienced i feel like sticking to conditional logic is easier for me. I thought about one method that just calculates all the possible combinations and another method which then chooses the shortest one available. – QWERTYZ Feb 06 '21 at 19:25

Janez Kuhar · Accepted Answer · 2021-02-28T22:44:47.483

Suppose you have:

an array of all possible coin VALUES: [10, 20, 50, 100, 200]
an array of the current SUPPLY of coins for each VALUE
an array of WEIGHS that correspond to VALUES (higher weigh, smaller value): [4, 3, 2, 1, 0]

then you could find a combination of coins that sums up to change and has the minimum total weight.

Let a combination c be the current combination of coins. For example, c = [0, 1, 1, 2, 0] would mean that you are considering a combination where you have no 10 cent coins, one 20 cent coin, one 50 cent coin, two 1€ coins and no 2€ coins.

You begin with combination c = [0, 0, 0, 0, 0].

Using weights will implicitly assure you that the resulting combination will have the minimum weight and is thus the result you are looking for. For example:

// Both combinations represent the change of 160 cents
c = [1, 0, 1, 1, 0] => weight: 4*1 + 3*0 + 1*2 + 1*1 + 0*0 = 7
c = [0, 3, 0, 1, 0] => weight: 4*0 + 3*3 + 0*2 + 1*1 + 0*0 = 10

Something like this should work:

import java.util.Arrays;
import java.util.stream.IntStream;

public class Change {
    /** The number of unique coins. */
    static final int N = 5;
    static final int[] VALUES = { 10, 20, 50, 100, 200 };
    static final int[] WEIGHTS = { 4, 3, 2, 1, 0 };
    static final int[] SUPPLY = { 10, 35, 40, 100, 2 };

    static int[][] result = {
        {
            // The minimum weight
            Integer.MAX_VALUE 
        },
        {
            // The resulting combination of coins
            0, 0, 0, 0, 0
        }
     };

    public static void main(String[] args) {
        int change = 160;
        solve(new int[N], change);

        if (result[0][0] == Integer.MAX_VALUE) {
            System.out.println(
                "Can't return the change with the given SUPPLY of coins"
            );
        } else {
            System.out.println(Arrays.toString(result[1]));
        }
    }

    static void solve(int[] c, int change) {
        // check if out of supply
        boolean isOutOfSupply = IntStream.range(0, N).anyMatch(i -> SUPPLY[i] < c[i]);
        if (isOutOfSupply) return;

        // compute weight
        int weight = IntStream.range(0, N).map(i -> WEIGHTS[i] * c[i]).sum();

        // compute sum
        int sum = IntStream.range(0, N).map(i -> VALUES[i] * c[i]).sum();

        if (sum == change && weight < result[0][0]) {
            result[0][0] = weight;
            result[1] = c;
        } else if (sum < change) {
            IntStream.range(0, N).forEach(i -> solve(increment(c, i), change));
        }
    }

    static int[] increment(int[] array, int index) {
        int[] clone = array.clone();
        clone[index]++;
        return clone;
    }
}

Coin change logic

2 Answers2