Function that calculates change

Question

I want to write a function that calculates the change a machine has to give a customer. The function receives the cost of the product, the sum of money the customer gave and a dictionary that has the money the machine has in it.

The function should give the smallest set of coins and bills and take into account the money available.

It should also avoid running out of any one kind of money; for example, if it has 2 of 10€ and 8 of 5€ it should not use the 2 of 10€ in the same change.

This is my dictionary:

d = {0.01: 10,
 0.02: 5,
 0.05: 2,
 0.1: 10,
 0.2: 5,
 0.5: 2,
 1: 5,
 2: 5,
 5: 2,
 10: 4,
 20: 5,
 50: 1,
 100: 0,
 200: 0,
 500: 0,
 }

and this is my code so far:

def change(cost, given, d):
last_change = 0
change = given - cost #calculates how much we own the customer
if change == 0: #if we don't own the customer anything
    return change
else:
    if change in d and d[change] != 0: #if change is in the dictionary and its value is not 0 we can give it to the customer
        return change
    else:
        euro = int(change)
        cent = change - euro #calculates if we have to give any cents
        if cent == 0: #if we only have to give bills
            for item in d:
                if item > last_change and item < change and d[item] != 0: #biggest bill we can give the customer
                    last_change = item

I don't know what to do next.

Answer 1

from math import *
dict1 = {0.01: 10,
 0.02: 5,
 0.05: 2,
 0.1: 10,
 0.2: 5,
 0.5: 2,
 1: 5,
 2: 5,
 5: 2,
 10: 4,
 20: 5,
 50: 1,
 100: 0,
 200: 0,
 500: 0,
 }

def change(cost, given, dict1):

    last_change = 0
    change = given - cost
    if change == 0: 
        print change
    else:
        if change in dict1 and dict1[change] != 0: 
        print change
        else:

        if change >= 500 and dict1[change] != 0:
            a = floor( change / 500 )
            print a, " --500 's"
            change = change - ( a * 500 )

        if change >= 200 and dict1[change] != 0:
            b = floor( change / 200 )
            print b, " --200 's"
            change = change - ( b * 200 )

        if change >= 100 and dict1[change] != 0:
            c = floor( change / 100 )
            print c, " --100 's"
            change = change - ( c * 100 )

        if change >= 50 and dict1[change] != 0:
            d = floor( change / 50 )
            print d, " --50 's"
            change = change - ( d * 50 )

        if change >= 20 and dict1[change] != 0:
            e = floor( change / 20 )
            print e, " --20 's"
            change = change - ( e * 20 )


        if change >= 10 and dict1[change] != 0:
            f = floor( change / 10 )
            print f, " --10 's"
            change = change - ( f * 20 )


        if change >= 5 and dict1[change] != 0:
            g = floor( change / 5 )
            print g, " --5 's"
            change = change - ( g * 5 )

        if change >= 2 and dict1[change] != 0:
            h = floor( change / 2 )
            print h, " --2 's"
            change = change - ( h * 2 )

        if change >= 1 and dict1[change] != 0:
            i = floor( change / 1 )
            print i, " --1 's"
            change = change - ( i * 1 )

        if change >= 0.5 and dict1[change] != 0:
            j = floor( change / 0.5 )
            print j, " --0.5 's"
            change = change - ( j * 0.5 )

        if change >= 0.2 and dict1[change] != 0:
            k = floor( change / 0.2 )
            print k, " --0.2 's"
            change = change - ( k * 0.2 )


                   ---------------------------
                   ---------------------------
                   ---------------------------
                   ---------------------------
           implement similar steps for 0.1,0.05,0.02,0.01

Output will be like this:

1  - 500 's
2  - 200 's
2  - 100 's
1  - 20 's

Answer 2

Here is some pseudo-code - there are some details you have to fill in:

   amount = ... the input amount ...
   change = {}
   for denomination in [500, 200, 100, 50, ...]:
     if amount == 0:
       break
     n = ... number of coins of this denomination to use
     change[denomination] = n         # store it
     amount = amount - n*denomination # subtract from amount
   # the dictionary change contains how to make the change