将 int 划分为较低的整数

Question

我有一个 30-60 范围内的随机整数，我使用 randint(30,60) 获得。假设它是 40。我想将这个数字分成 7 个随机整数。因此，例如 [5,5,5,5,5,5,10] 是一个有效的结果。但是有很多可能的解决方案，比如这个[6,6,6,6,6,6,4] 或[4,2,9,13,8,1,3] ... 我知道有很多解决方案，但我正在寻找一种快速的方法来解决它们。我并不是想获得每一个解决方案，而是寻找一种快速的方法来在短时间内迭代其中的很多。实现它的一种方法是随机选择一个数字（假设在 1-15 的范围内）并将其保存到一个列表中，然后执行一个 while 循环，直到总和正好为 40。我试过了，但效率不高全部。我认为选择[5,5,5,5,5,5,10] 之类的起始值并以"1st digit -2" 和3rd +2 之类的精确方式更改数字以产生[3,5,7,5,5,5,10] 将是一个更快的解决方案。有谁知道如何做到这一点或有一个好的建议？谢谢。我更喜欢python 3。

Answer 1

一组整数和一个数n 称为partition 的n；如果顺序很重要，那么它被称为组合。

这是一种产生随机组合的相当快速的方法。

import random

def random_partition(n, size):
    seq = []
    while size > 1:
        x = random.randint(1, 1 + n - size)
        seq.append(x)
        n -= x
        size -= 1
    seq.append(n)
    return seq

n = 40 
for _ in range(20):
    print(random_partition(n, 7))

典型输出

[26, 2, 8, 1, 1, 1, 1]
[30, 2, 1, 3, 1, 1, 2]
[26, 5, 3, 1, 2, 2, 1]
[2, 25, 9, 1, 1, 1, 1]
[28, 2, 2, 2, 1, 2, 3]
[23, 1, 9, 3, 2, 1, 1]
[3, 26, 1, 7, 1, 1, 1]
[25, 1, 7, 1, 2, 1, 3]
[10, 8, 11, 5, 3, 1, 2]
[19, 16, 1, 1, 1, 1, 1]
[12, 23, 1, 1, 1, 1, 1]
[1, 14, 15, 7, 1, 1, 1]
[29, 5, 1, 1, 2, 1, 1]
[25, 1, 3, 3, 1, 2, 5]
[10, 12, 10, 4, 1, 2, 1]
[13, 4, 6, 14, 1, 1, 1]
[31, 3, 1, 1, 1, 1, 2]
[16, 11, 9, 1, 1, 1, 1]
[3, 26, 5, 3, 1, 1, 1]
[31, 2, 1, 2, 2, 1, 1]

我们使用1 + n - size 作为上限，因为其他size - 1 数字至少为1。

这是一种相当有效的方法来生成给定整数的所有分区。请注意，这些是有序的；如果你想从这些分区产生随机组合，你可以使用random.shuffle。

我们首先打印大小为 5 的 16 个分区，然后我们计算大小为 7 的 40 个分区的数量 (= 2738)。

此代码源自Jerome Kelleher 的算法。

def partitionR(num, size):
    a = [0, num] + [0] * (num - 1)
    size -= 1
    k = 1
    while k > 0:
        x = a[k - 1] + 1
        y = a[k] - 1
        k -= 1
        while x <= y and k < size:
            a[k] = x
            y -= x
            k += 1
        a[k] = x + y
        if k == size:
            yield a[:k + 1]

for u in partitionR(16, 5):
    print(u)

print('- ' * 32)
print(sum(1 for _ in partitionR(40, 7)))

输出

[1, 1, 1, 1, 12]
[1, 1, 1, 2, 11]
[1, 1, 1, 3, 10]
[1, 1, 1, 4, 9]
[1, 1, 1, 5, 8]
[1, 1, 1, 6, 7]
[1, 1, 2, 2, 10]
[1, 1, 2, 3, 9]
[1, 1, 2, 4, 8]
[1, 1, 2, 5, 7]
[1, 1, 2, 6, 6]
[1, 1, 3, 3, 8]
[1, 1, 3, 4, 7]
[1, 1, 3, 5, 6]
[1, 1, 4, 4, 6]
[1, 1, 4, 5, 5]
[1, 2, 2, 2, 9]
[1, 2, 2, 3, 8]
[1, 2, 2, 4, 7]
[1, 2, 2, 5, 6]
[1, 2, 3, 3, 7]
[1, 2, 3, 4, 6]
[1, 2, 3, 5, 5]
[1, 2, 4, 4, 5]
[1, 3, 3, 3, 6]
[1, 3, 3, 4, 5]
[1, 3, 4, 4, 4]
[2, 2, 2, 2, 8]
[2, 2, 2, 3, 7]
[2, 2, 2, 4, 6]
[2, 2, 2, 5, 5]
[2, 2, 3, 3, 6]
[2, 2, 3, 4, 5]
[2, 2, 4, 4, 4]
[2, 3, 3, 3, 5]
[2, 3, 3, 4, 4]
[3, 3, 3, 3, 4]
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
2738

Answer 2

如果您只关心获得一组任意数字，这些数字加起来等于您的总数，而不是对 所有 组合进行详尽的迭代，那么以下内容应该会让您得到您想要的需要。

def get_parts(total, num_parts=7, max_part=15):
    running_total = 0
    for i in range(num_parts - 1):
        remaining_total = total - running_total
        upper_limit = min(max_part, remaining_total - num_parts + 1 + i)
        # need to make sure there will be enough left
        lower_limit = max(1, remaining_total - max_part*(num_parts - i - 1))
        part = randint(lower_limit, upper_limit)
        running_total += part
        yield part
    yield total - running_total

>>> list(get_parts(40))
[2, 7, 10, 11, 1, 4, 5]

>>> list(get_parts(40))
[7, 13, 11, 6, 1, 1, 1]

>>> list(get_parts(50, 4))
[6, 14, 15, 15]

当然，上面每个列表中的项目并不是真正随机的，并且列表中前面的数字较大，后面的数字较小。如果你想要更多的伪随机元素，你可以通过 random.shuffle() 提供这些列表。

Answer 3

来自Python Integer Partitioning with given k partitions

def partitionfunc(n,k,l=1):
    '''n is the integer to partition, k is the length of partitions, l is the min partition element size'''
    if k < 1:
        raise StopIteration
    if k == 1:
        if n >= l:
            yield (n,)
        raise StopIteration
    for i in range(l,n//k+1):
        for result in partitionfunc(n-i,k-1,i):
            yield (i,)+result
list(partitionfunc(40,7))

Answer 4

您可以对前 6 个值（总和不超过 40）的所有可能组合进行简单迭代，并计算第 7 个值。

for a in range(41):
    for b in range(41-a):
        for c in range(41-(a+b)):
            for d in range(41-(a+b+c)):
                for e in range(41-(a+b+c+d)):
                    for f in range(41-(a+b+c+d+e)):
                        g = 40 - (a+b+c+d+e+f)
                        # Do what you need to do here

通过预先计算总和，您可以将循环所需的时间几乎减少一半（根据使用 timeit 的测试）：

for a in range(41):
    for b in range(41-a):
        ab = a + b
        for c in range(41-ab):
            abc = ab + c
            for d in range(41-abc):
                abcd = abc + d
                for e in range(41-abcd):
                    abcde = abcd + e
                    for f in range(41-abcde):
                        g = 40 - (abcde + f)
                        # Do what you need to do here