如何有效地生成和过滤列表产品列表的所有组合

Question

大家好，这是问题所在。我在输入 [[1,2,3],[4,5,6],[7,8,9]]...等中有这样的东西

我想生成这些列表的所有可能的产品组合，然后将结果组合的每个元素相乘，最终在一个区间内过滤结果。

所以先输入一个n列表[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]...等

然后会给出 (1,4,7,10) (1,4,7,11) (1,4,7,12) 等等

然后将 n 中 k 的结果组合起来，例如第一行的 (1,4,7)(1,4,10)(1,7,10)

x 的乘积为 1*4*7 = 28, 1*4*10 = 40, 1*7*10 = 70

从中只得到唯一组合和预先选择的区间内需要的结果：如果 x > 50 和 x

我试过

    def mult(lst):                 #A function mult i'm using later
        r = 1
        for element in lst:
           r *= element
        return round(r)

    s = []                                #Where i add my list of list
    for i in range(int(input1)):
        b = input("This is line %s : " % (i+1)).split()
        for i in range(len(b)):
           b[i] = float(b[i]) 
        s.append(b)

    low_result = input("Expected low_result : ")
    high_result = input("Expected high_result : ")

    combine = []
    my_list = []

    for element in itertools.product(*s):
       l= [float(x) for x in element]
       comb = itertools.combinations([*l], int(input2))
       for i in list(comb):
          combine.append(i)
          res = mult(i)
          if res >= int(low_result) and res <= int(high_result):
             my_list.append(res) 
             f = open("list_result.txt","a+")
             f.write("%s : result is  %s\n" % (i, res))
             f.close()

它总是导致内存错误，因为我正在寻找的变化太多。

我想要的是一种从包含 20 个或更多元素的列表中生成所有产品的方法，并为我需要的结果（间隔）生成 n 中的 k 组合。

Answer 1

正如上面所建议的，我认为这可以通过在任何时候都不在内存中保存数组来完成，而不会爆炸你的内存。但主要问题是运行时。

数学

我们是这样写的：

• 产生m行n项目n ** m的每个组合
• 然后从m 值C(m, c) 中选择c 项目

这是非常大的。如果我们有m=25 行，每个n=3 项并在其中选择c=3 项，我们得到：

• = n ** m * C(m, c)
• = 3 ** 25 * 2300 - n Choose r calculator
• = 1.948763802×10¹⁵

如果我们：

• 从m 行中选择c 行：C(m, c) 和以前一样
• 然后从这些c 行中选择n 项目的每个组合：n ** c

使用m=25 行，每个n=3 项，然后在其中选择c=3 项，我们得到：

• = n ** c * C(m, c)
• = 3 ** 3 * 2300
• = 20700

现在这是一个可以解决的问题。

代码

from itertools import product, combinations


def mult(values, min_value, max_value):
    """
    Multiply together the values, but return None if we get too big or too
    small
    """
    output = 1

    for value in values:
        output *= value

        # Early return if we go too big
        if output > max_value:
            return None

        # Early return if we goto zero (from which we never return)
        if output == 0 and min_value != 0:
            return None

    if output < min_value:
        return None

    return output


def yield_valid_combos(values, choose, min_value, max_value):
    # No doubt an even fancier list compression would get this too
    for rows in combinations(values, choose):
        for combos in product(*rows):
            value = mult(combos, min_value, max_value)

            if value is not None:
                yield combos, value


values = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]


with open('list_result.txt', 'w') as fh:
    for selection, value in yield_valid_combos(
            values, choose=3, min_value=50, max_value=100):
        fh.write('{}: result is {}\n'.format(selection, value))

此解决方案也不会返回重复的答案（除非相同的值出现在多行中）。

作为一种优化，如果我们检测到结果太大或太小，乘法方法会尝试提前返回。我们也只打开文件一次，然后不断向其中添加行。

进一步优化

您还可以通过筛选出对解决方案没有帮助的值来提前优化您的值集。但是对于较小的 c 值，您可能会发现这甚至没有必要。

值的最小可能组合是每行中最小值集合中的c 个项目。如果我们从最小值集合中取出c - 1 最小的项目，将它们相乘，然后将最大值除以这个数字，它为我们提供了一个可以在解决方案中的最大值的上限。然后我们可以筛选掉所有高于这个值的值（减少排列）