查找固定大小的所有唯一组合以达到给定的平均范围

Question

我有一个整数范围，例如

big_list = [1, 2, ..., 100]

我需要找到这个范围内所有固定长度的数字子集，对于 k=5，它们的平均值在 50 以内（如 45-55）。例如我们的固定大小为 6，平均约为 50

sample = [71, 20, 23, 99, 25, 60]

问题是列表必须是唯一的，不能有重复的数字。

顺序无关紧要，因此 [71, 20, 23, 99, 25, 60] 和 [20, 71, 23, 99, 25, 60] 只是一种组合。

我正在考虑仅使用 itertools 生成所有组合并根据我的标准过滤掉。但是运行时间会很糟糕，因为大的数字列表可能从 10 到 400 不等。

如何根据上述条件生成一组列表

Answer 1

订单是微不足道的。

只需安排 i-th 数字大于 (i-1)-th 的约束即可。在下面的算法中，您通过将 left 递增 1 来递归

要获得 45 到 55 之间的平均值，请考虑递归公式

import math

# left: previous number is left-1
# s: current sum
# d: depth
# c: combination
def fill(left, s, d, c):
  if d == 0:
    return print(c, sum(c)/n)

  # constraint c_sum >= 45*n
  # we look for minimal i such that 
  # sum + i + 100+99+...+(100-(depth-1)+1) >= 45*n
  # sum + i + 100*(d-1) - (d-2)(d-1)/2 >= 45*n
  # i >= 45*n - 100*(d-1) - (d-2)(d-1)/2 - sum
  # 
  # constraint c_sum <= 55*n
  # we look for maximal right such that
  # sum + i + (i+1)+...+(i+(d-1)) <= 55*n
  # sum + (d-1)*i + d(d-1)/2 <= 55*n
  # i <= ( 55*n - d(d-1)/2 - sum )/(d-1)
  minleft = max(left, math.ceil(minBound*n - 100*(d-1) - (d-2)*(d-1)/2 - s))
  if d == 1:
    maxright = min(100, maxBound*n-s)
  else:
    maxright = min(100, math.floor(( maxBound*n - d*(d-1)/2 - s )/(d-1)) )
  for i in range(minleft, maxright+1):
    newsum = s + i
    c[d-1] = i
    fill(i+1, newsum, d-1, c)

n = 6
minBound = 45
maxBound = 55
fill(0, 0, n, [0]*n)

---

在进一步的 cmets 之后，op 对上述组合完全不感兴趣，而是对所有组合中没有数字可以出现两次的组合感兴趣

算法可以简化为最基本的算法：

n = 300
c = list(range(1, n))
while len(c) >= 6:
  print([c.pop(), c.pop(), c.pop(), c.pop(0), c.pop(0), c.pop(0)])

Answer 2

您可以将递归与生成器一起使用：

def combo(d, k, c = []):
   if len(c) == 6:
      yield c
   else:
      for i in d:
        _c = (sum(c)+i)/float(len(c)+1)
        if i not in c and (len(c) + 1 < 6 or 50-k <= _c <= 50+k):
            yield from combo(d, k, c+[i])

当然，正如@japreiss 所指出的，这个问题会产生非常糟糕的最坏情况时间复杂度。然而，一种可能的解决方法是将combo 视为一个迭代器池，并在代码中的其他地方简单地按需访问生成的组合。例如，要访问前 100 个结果：

result = combo(range(1, 100), 5)
for _ in range(100):
   print(next(result))

输出：

[1, 2, 3, 67, 98, 99]
[1, 2, 3, 67, 99, 98]
[1, 2, 3, 68, 97, 99]
[1, 2, 3, 68, 98, 99]
[1, 2, 3, 68, 99, 97]
[1, 2, 3, 68, 99, 98]
[1, 2, 3, 69, 96, 99]
[1, 2, 3, 69, 97, 98]
[1, 2, 3, 69, 97, 99]
[1, 2, 3, 69, 98, 97]
...