PYTHON : Find all combinations from a list with condition using recursion

There are some problems with this code.

First, this part of code:

 if len(results) > 0:
     results = [results[0]]
 elif len(closest_combination) > 0:
     results = [closest_combination]
 else:
     return []

Gets the first result. So it won't print all the results for you.

Second, in your backtrack function when no new items can be added to the list it won't append the combination that it already has. You can fix this part of code with a boolean like this:

can_add_new_one = False
for i in range(start, len(items)):
        for j in range(1, items[i][2] + 1):
            if target_sum - items[i][1] * j >= 0:
                can_add_new_one = True
                backtrack(i + 1, target_sum - items[i][1] * j, combination + [(items[i][0], j)])
            if abs(target_sum - items[i][1] * j) < closest_diff:
                closest_diff = abs(target_sum - items[i][1] * j)
                closest_combination = combination + [(items[i][0], j)]
 if not can_add_new_one:
     results.append(combination)

Also, the 'most_expensive' part doesn't work. You can add items prices to the results list to be able to calculate most expensive result between all the results.

This would fix the problem with the code. The final code would be like this:

def find_combinations(items, target_sum, result_type='full'):
    items = sorted(items, key=lambda x: x[1], reverse=True)
    results = []
    closest_diff = float('inf')
    closest_combination = []

    def backtrack(start, target_sum, combination):
        nonlocal closest_diff
        nonlocal closest_combination
        nonlocal results

        if target_sum < 0:
            return 
        if target_sum == 0:
            results.append(combination)
            return
        if start == len(items):
            return

        can_add_new_one = False
        for i in range(start, len(items)):
            for j in range(1, items[i][2] + 1):
                if target_sum - items[i][1] * j >= 0:
                    can_add_new_one = True
                    backtrack(i + 1, target_sum - items[i][1] * j, combination + [(items[i][0], j, items[i][1])])
                if abs(target_sum - items[i][1] * j) < closest_diff:
                    closest_diff = abs(target_sum - items[i][1] * j)
                    closest_combination = combination + [(items[i][0], j)]
        if not can_add_new_one:
            results.append(combination)
            

    backtrack(0, target_sum, [])

    if result_type == 'full':
        return results
    elif result_type == 'most_items':
        return [max(results, key=lambda x: sum(map(lambda y: y[1], x)))]
    elif result_type == 'most_expensive':
        return [max(results, key=lambda x: sum(map(lambda y: y[2] * y[1], x)))]
    else:
        return results