Question

采用以下值：

0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0

我想创建一个生成64x4矩阵的函数，一个256个元素的矩阵，其中包括上述11个值的总和为1的每个值

任何有关高效方法的帮助都非常有帮助。

Answer 1

以下代码可以满足您的需求。我使用了最多加10的整数，以避免浮点舍入错误。你可以通过提前摆脱循环来更快地运行它，并且在提升StopIteration之前不要让它一直向下钻，但这会使代码不那么清晰。

def partitions(n=10, items=range(11), count=4) :
    if count == 0 and n == 0:
        yield []
    elif n < 0 or count < 0:
        raise StopIteration
    for j in xrange(len(items)) :
        ret = [items[j]]
        for k in partitions(n-items[j], items[j:], count-1) :
            yield ret + k

>>> [j for j in partitions()]
[[0, 0, 0, 10], [0, 0, 1, 9], [0, 0, 2, 8], [0, 0, 3, 7], [0, 0, 4, 6],
 [0, 0, 5, 5], [0, 1, 1, 8], [0, 1, 2, 7], [0, 1, 3, 6], [0, 1, 4, 5],
 [0, 2, 2, 6], [0, 2, 3, 5], [0, 2, 4, 4], [0, 3, 3, 4], [1, 1, 1, 7],
 [1, 1, 2, 6], [1, 1, 3, 5], [1, 1, 4, 4], [1, 2, 2, 5], [1, 2, 3, 4],
 [1, 3, 3, 3], [2, 2, 2, 4], [2, 2, 3, 3]]

我不太确定你在哪里想出会有64个这样的子集。

提供上述功能

>>> len([j for j in partitions()])
23

4个元素的有序子集。如果您不希望订购子集，可以通过在递归调用中使用完整partitions而不是items调用items[j:]来获取该子集。但是你得到了

>>> len([j for j in partitions()])
286

如果你不限制自己的4个元素的子集，那么我们必须摆脱0（有无限的子集，最多10个，任意数量的零），然后我们计算的partitions为10，The Answer to the Ultimate Question of Life, The Universe, and Everything或42。

Answer 2

正如Jaime所说，动态编程可能在这里证明是有用的。您可以将此问题定义为通过树的递归搜索，其中树中的每个节点都包含一些预先指定的元素。树的叶子包含总和为1的所有组合。

因此，在搜索的每一步中：

选择下一个不会使总和超过1的数字。
将此数字添加到您的数字集中 - 这个集合将是下一个节点。
从此节点重复，直到您到达离开节点（sum == 1）。

一旦完全探索了节点N下的所有节点，或者N是一个离开节点：转到其父节点并重复步骤1到3.

创建4列矩阵，其中包含从0到1的11个值的所有组合，增加0.1。

2 个答案: