Kearney Taaffe - 5 months ago 32

Python Question

I had an interesting interview question that I'm having a hard time solving (I have 7 of the 10 permutations)

The question was

Find all possible permutations to make change given the following coins, 25¢, 10¢, 5¢. The answer MUST BE saved in a list, and MUST BE returned as a JSON string when the method is called

Furthermore, the requirements were that when printed, the solution MUST look like this

For instance, given an amount of 50¢, the solution should look like

the following when printed out

`25: 2, 10: 0, 5: 0`

25: 1, 10: 1, 5: 3

25: 1, 10: 2, 5: 1

25: 1, 10: 0, 5: 5

25: 0, 10: 5, 5: 0

25: 0, 10: 4, 5: 2

25: 0, 10: 3, 5: 4

25: 0, 10: 2, 5: 6

25: 0, 10: 1, 5: 8

25: 0, 10: 0, 5: 10

Needless to say, after 2 hours (the time limit to the test) I was unable to finish. But, it got me wandering, if I could solve the problem. I've tried for the past 6 hours to get the result, but the best I can come up with is

`1 => {25: 2, 10: 0, 5: 0}`

2 => {25: 1, 10: 1, 5: 3}

3 => {25: 1, 10: 2, 5: 1}

4 => {25: 1, 10: 0, 5: 5}

5 => {25: 0, 10: 5, 5: 0}

6 => {25: 0, 10: 1, 5: 8}

7 => {25: 0, 10: 0, 5: 10}

Using this code

`class ChangeMachine(object):`

def __init__(self, amount, coins=[25, 10, 5]):

self.amount = amount

self.coins = coins

self.result = []

self.initial_way = {}

for coin in coins:

self.initial_way[coin] = 0

def getAllPermutations(self):

for index in xrange(0, len(self.coins)):

coin = self.coins[index]

self.changeFromSameCoin(self.amount, coin)

self.changeUsingOneCoin(self.amount, coin, self.coins[index + 1:])

def changeFromSameCoin(self, amount, coin):

"""loops through all the coins, finding the ones which can be divided

into the amount evenly

Args:

amount: int

coin: int

Returns:

None

"""

way = dict(self.initial_way)

if amount % coin == 0:

way[coin] = amount / coin

self.result.append(dict(way))

def changeUsingOneCoin(self, amount, initial_coin, coin_list):

"""Makes change using 1 large coin and the rest small coins

Args:

amount: int

initial_coin: int - the "large" denomination that is to be used once

coin_list: list - contains the remainder of the coins

"""

if amount <= initial_coin:

return

remainder = amount - initial_coin

init_way = dict(self.initial_way)

num_coins = len(coin_list)

coin_used = 0

outer_counter = 0

# keep track of the number of times the outer coins are used

# make it 1 because the outer coin has to be used at least once

# even if outer coin is > remainder, we are still trying to use

# it once

outer_coin_used = 1

# since the initial coin MUST BE used at least once, go ahead and

# create an initial dictionary that has the initial coin used

# once

init_way[initial_coin] = 1

while outer_counter < num_coins:

outer_coin = coin_list[outer_counter]

# initialize way on every loop

way = dict(init_way)

# subtract the current outer coin from the remainder. We do this

# because if the remainder is 0, then it means that only 1 of this

# coin and the initial coin are needed to make change

# If the remainder is negative, then, one of the larger coin and

# one of this coin, cannot make change

# The final reason is because if we make change with the other

# coins, we need to check if we double, triple, etc this coin

# that we can still make change.

# This helps us find all permutations

remainder -= (outer_coin * outer_coin_used)

if remainder < 0:

# move to next coin using the outer_counter

outer_counter += 1

# reset the remainder to initial - large coin

remainder = amount - initial_coin

# rest the times the coin was used to 1

outer_coin_used = 1

continue

way[outer_coin] += outer_coin_used

if remainder == 0:

# add the way we just found to our result list

self.result.append(dict(way))

# move to the next element in the list

outer_counter += 1

# reset the remainder, our way result set, and times the

# outer coin was used

remainder = amount - initial_coin

way = dict(init_way)

outer_coin_used = 0

continue

# so, if we got here, the outer coin reduced the remainder, but

# didn't get it to 0

for index in range(outer_counter + 1, num_coins):

# our goal here is to make change with as few of coins as

# possible

inner_coin = coin_list[index]

if remainder % inner_coin == 0:

way[inner_coin] = remainder / inner_coin

remainder = 0

break

if remainder - inner_coin < 0:

# this coin is too large, move onto the next coin

continue

# this coin goes into the remainder some odd number of times

# subtract it from our remainder and move onto the next coin

remainder /= inner_coin

way[inner_coin] += remainder

# end for index in range()

if remainder == 0:

# we found a way to make change, save it

self.result.append(dict(way))

# reset the remainder to initial - large coin

remainder = amount - initial_coin

# increment the outer coin used by 1, because we will try

# to decrement remainder by more than 1 outer coin

outer_coin_used += 1

# end while loop

return

# end def changeUsingOneCoin()

# end class

from pprint import pprint

def main(amount, coins=[25, 10, 5]):

result = []

amount = 50

coins = [25, 10, 5]

cm = ChangeMachine(amount, coins)

# cm.changeUsingOneCoin(amount, coins[0], coins[1:])

cm.getAllPermutations()

counter = 1

for record in cm.result:

print "{} => {}".format(counter, record)

counter += 1

return result

if __name__ == '__main__':

"""

Result MUST BE a list of dictionaries containing all possible answers

For Example: if main(50, [25, 10, 5]) should return

[

{25: 2},

{25: 1, 10: 2, 5: 1},

{25: 1, 10: 1, 5: 3},

{25: 1, 10: 0, 5: 5},

{25: 0, 10: 5, 5: 0},

{25: 0, 10: 4, 5: 2},

{25: 0, 10: 3, 5: 4},

{25: 0, 10: 2, 5: 6},

{25: 0, 10: 1, 5: 8},

{25: 0, 10: 0, 5: 10},

]

"""

result = main(50)

I know I'm not going to get the job. But, I really want to know the solution

Recommended for you: Get network issues from **WhatsUp Gold**. **Not end users.**

Answer Source

This simpler code does it, except that it doesn't write the output as JSON.

I would be suspicious of an employer that calls these 'permutations'. :)

```
TOTAL = 50
for q in range(0, 1+50//25):
remainder_q = TOTAL - 25*q
for d in range(0, 1+remainder_q//10):
remainder_d = remainder_q - 10*d
for n in range(0, 1+remainder_d//5):
remainder_n = remainder_d - 5*d
if 25*q+10*d+5*n == 50:
print (q, d, n)
break
if 25*q+10*d+5*n > 50:
break
0 0 10
0 1 8
0 2 6
0 3 4
0 4 2
0 5 0
1 0 5
1 1 3
1 2 1
2 0 0
```

Recommended from our users: **Dynamic Network Monitoring from WhatsUp Gold from IPSwitch**. ** Free Download**