总和在给定范围内的列表列表（作业）

Question

我想定义一个接受以下参数的函数： - 一个数字列表 - 最低限度 - 最大值

它应该返回一个列表（或集合）列表，其中每个列表的总和在最小值和最大值之间。列表中不应有重复项。

我所拥有的并没有返回所有可能的列表：

def givelists(List, minimum, maximum):
    currentlist = [] #list to keep track of sum of currently included subset of list
    listoflist = [] #list of all lists of which the sum is between specified minumum and maximum
    for number in List:
        if minimum < (sum(currentlist) + number) < maximum:
            currentlist.append(number)
            listoflist.append(currentlist)
            currentlist = []
        elif (sum(currentlist) + number) < minimum:
            currentlist.append(number)
        else:
            if number in range(minimum, maximum):
                listoflist.append(number)
    return(listoflist)

例如：

givelists(list(range(1,6)), 2, 8)

# Output: [[1, 2], [3], [4], [5]]

Answer 1

试试这个：

from itertools import chain, combinations

def powerset_sum(iterable, minimum, maximum):
    s = set(iterable)
    combs = chain.from_iterable(combinations(s,r) for r in range(len(s)+1))
    valid_combs = [list(comb) for comb in combs if (minimum < sum(comb) < maximum)]
    return valid_combs
print(powerset_sum(list(range(1,6)), 2, 8))

输出：

[[3],
 [4],
 [5],
 [1, 2],
 [1, 3],
 [1, 4],
 [1, 5],
 [2, 3],
 [2, 4],
 [2, 5],
 [3, 4],
 [1, 2, 3],
 [1, 2, 4]]

Answer 2

你需要考虑列表中数字的多种组合，比如；

for every number in the list:
    test if that number is a feasible solution
    for every other number in the list:
        test if they can be grouped with that number \
        and produce a feasible solution # (recursion here)

所以主要是你的代码应该是这样的

def sums_in_range(lst, min, max):
    result = []
    for i, number in enumerate(lst):
        if min < number < max:
            result.append([number])
        candidates = sums_in_range(
            [test for test in lst[i+1:] if test < max-number], min-number, max-number)
        for candidate in candidates:
            result.append([number]+candidate)
    return result

print(sums_in_range(sorted(list(range(1, 6))), 2, 8))

注意事项：

• 我在lst[i+1:] 中使用i+1，因此它不会返回带有重复项的列表，例如[1, 1, 1]
• 我正在做lst[i+1:] 所以它不会计算像[1, 2] 和[2, 1] 这样的重复项
• sorted 考虑负值，请参阅 cmets

编辑

为了完整起见（我有一些空闲时间），如果你想更进一步

我已经对此处发布的 3 个答案进行了比较，内存和时间明智的数据相同

你可以找到重现结果的代码here

这就是我想出的结果

测试输入是

test_lst = list(range(1, 25))
test_min = 2
test_max = 50

Answer 3

这是一个不使用导入模块的递归解决方案：

def get_lists_in_range(lst, minimum, maximum):
    result = []
    for i, item in enumerate(lst):
        #print(i, item, lst[i+1:])
        all_lists = get_lists_in_range(lst[i+1:], minimum, maximum)
        if minimum <= item <= maximum:
            result.append([item])
        for l in all_lists:
            if minimum <= item + sum(l) <= maximum:
                result.append([item] + l)           
    return result

print(get_lists_in_range(list(range(1, 6)), 2, 8))

Answer 4

这是一个递归生成器函数，它执行backtracking search，并进行了一些优化。首先对列表进行排序，计算每个索引后的正负数之和；这些可以用作可以用剩余元素得出的总和的界限。这为包含负数的列表提供了正确答案。作为对列表排序的副作用，子集按字典顺序查找。

对于组合问题，生成器函数通常比在列表中返回所有结果更有用，因为可能存在大量解决方案，而且您通常不需要一次将它们全部存储在内存中。但是，yield 比 append 慢一点，所以如果您总是希望结果显示在列表中，我已经展示了使用 cmets 进行的适当更改。

def subsets_sum_in_range(lst, min_s, max_s):
    lst = sorted(lst)
    n = len(lst)
    pos_sums = [0] * (n + 1)
    neg_sums = [0] * (n + 1)
    for i in reversed(range(n)):
        pos_sums[i] = pos_sums[i+1] + max(0, lst[i])
        neg_sums[i] = neg_sums[i+1] + min(0, lst[i])

    def helper(i, s, t):
        if min_s <= s <= max_s:
            yield t
            # out.append(t)
        for j in range(i, n):
            if s + pos_sums[j] < min_s or s + neg_sums[j] > max_s:
                break
            v = lst[j]
            yield from helper(j + 1, s + v, t + (v,))
            # helper(j + 1, s + v, t + (v,))

    return helper(0, 0, ())
    # out = []
    # helper(0, 0, ())
    # return out

例子：

>>> list(subsets_of_sum([1, 2, 3, 4, 5], 3, 6))
[(1, 2),
 (1, 2, 3),
 (1, 3),
 (1, 4),
 (1, 5),
 (2, 3),
 (2, 4),
 (3,),
 (4,),
 (5,)]