递归调用函数

Question

我有10张，20张，50张钞票，当我需要支付任何金额时，我需要找到最好的组合。例如，当我需要付7英镑时，我会付5英镑和2英镑的钞票

我有一个函数可以计算这个。但我需要运行同一个函数3到4次，如下所示。如何递归调用函数？在

my_dir={}
import bisect
def my_change(my_amount):
    c=[1,2,5,10,20,50,100,500]
    my_pos=bisect.bisect(c, my_amount)
    my_val=c[my_pos-1]
    my_num=my_amount//my_val
    my_recurr=my_amount-(my_num*c[my_pos-1])
    my_dir[my_val] = my_num
    return my_recurr

有没有更好的计算方法？在

^{pr2}$

---

更新：

根据可用的情况，组合可能会改变！在

^{3}$

应导致：

actual_pay={1:1, 2: 3, 10: 1, 50:6, 100: 1}

---

更新：

有没有更好的编码方法？在

amt=417
my_dict={}
available_cash={1:20, 2:10, 10:100, 50:100, 100:1, 500:1}
new_list=sorted(available_cash, reverse=True)

for key in new_list:
    if amt >= key * available_cash[key]:
        my_dict[key] = available_cash[key]
        amt = amt - (key * available_cash[key])
    else:
        if amt >= key:
            notes = amt // key
            amt = amt - (key * notes)
            my_dict[key] = notes

---

更新1：

如果我需要在付款后找到自动取款机里的钞票，我可以用柜台

from collections import Counter
A = Counter(available_cash)
B = Counter(my_dict)

A - B
Counter({10: 99, 50: 94, 1: 19, 2: 7, 500: 1})

Answer 1

你甚至不需要使用递归，你可以在一段时间内包装，所以它会一直计算直到更改为0，基本上与手动操作相同，但只需运行1次：

my_dir={}
import bisect
def my_change(my_amount):
    my_dict={}
    c=[1,2,5,10,20,50,100,500]
    while (my_amount > 0 ):
        my_pos=bisect.bisect(c, my_amount)
        my_val=c[my_pos-1]
        my_num=my_amount//my_val
        my_recurr=my_amount-(my_num*c[my_pos-1])
        my_dir[my_val] = my_num
        my_amount = my_recurr
    return my_dir

Answer 2

您可以使用类似于：

my_dir = {}
change = 417
def my_change(my_amount):
    # Your function code here
while change > 0:
    change = my_change(change)

但实际上，您的代码可以简化，递归的解决方案是：

^{pr2}$

不需要bisect或复杂的计算。在

Answer 3

如果您坚持递归地执行它，您可以使用一个小helper函数来实现，该函数以不断减少的数量调用自身（直到它达到零），并将迄今为止使用的注释集传递给自己。像

import collections

notes = [500, 100, 50, 20, 10, 5, 2, 1]

def my_change(amount):
    def go(amount, notesUsed):
        if amount <= 0:
            return notesUsed
        largestNote = next(x for x in notes if x <= amount)
        notesUsed[largestNote] += 1
        return go(amount - largestNote, notesUsed)

    return go(amount, collections.defaultdict(int))

go是一个执行实际递归的本地助手函数，defaultdict用于计数音符。在