我正在编写一些代码并最终遇到了这个问题。我有 N 个产品，我必须形成这些产品的所有可能组合，形成产品目录并找到一些属性，例如价格。为了做到这一点，我必须根据给定的产品形成产品目录（详尽，但不允许重复）。是否有一个标准化的算法来做到这一点？请注意，目录可以包含任意正数的产品。

可能的重复：
PHP 接受所有组合

我正在考虑用 PHP 制作一些东西来显示车牌的所有组合。例如：

您有 3 个框，最多可以填写 2 个值

喜欢

BOX1 BOX2 BOX3
75   PM   M5 
7S   PH   MS
Z5   PN   H5
ZS   RM   HS
25   RH   N5
2S   RN   NS

NOT BOX1+BOX1+BOX1
It needs to show me
ex. 75-PM-M5
ex. 75-PH-MS
ex. 75-PN-MS
ex. 75-PM-H5
ex. 75-PH-H5
ex. 75-PN-H5
So, BOX1+BOX2+BOX3

The PHP script needs to calculate all the combinations for BOX1+BOX2+BOX3
So BOX1 value1 and value2 are ONE value not two separate values. 
In BOX2 value1 …

我想从某个向量中获取一个矩阵x=(x_1,x_2, ..., x_I)，其中该矩阵中的每一行 i 对应于x(i) := (x_1,...,x_{i-1},x_{i+1},...,x_I)。

我知道

from sklearn.cross_validation import LeaveOneOut
I = 30
myrowiterator = LeaveOneOut(I)
for eachrow, _ in myrowiterator:
    print(eachrow)    # prints [1,2,...,29]
                      #        [0,2,...,29] and so on ...

提供一个例程来获取上述矩阵的每一行。但我宁愿直接一步获得矩阵，直接对该矩阵进行操作，而不是循环遍历它的行。这会节省我一些计算时间。

我有一些集合，我想对其进行笛卡尔积，效果很好。但是，我想删除这个新集合中在元素排列下相同的所有元素。

例如，采用以下代码：

import itertools as ittools
x = 2
y = 3
z = 5

flist = list(ittools.product([x,y,z],repeat=3))

for f in flist:
    print reduce(lambda a,b: a*b, f)

此代码查找集合 {2,3,5} 的笛卡尔积，并返回结果集中每个元素的所有三个分量的乘积。然而，有些数字会出现多次，即12可以写成2*2*3、2*3*2或3*2*2。我想删除这些重复项中除一个实例之外的所有实例。

我知道这从根本上来说是一个组合问题，但这似乎在 Python 中可能有一个很好的解决方案，它不需要像我在这里所做的那样对列表进行额外的传递来计算笛卡尔积的每个元素的一些标识符。

考虑二叉树，其中每个节点要么是叶子节点，要么恰好拥有两个子节点（左右，我们认为是不同的）。n节点上有多少种不同的树？
例如：
- 3 个节点 -> 1 棵树，
- 4-> 0 棵树，
- 5 -> 2 棵树，
- 6 -> 0 棵树，
- 7 -> 5 棵树，
- 等等......
有什么公式对于这个序列？我已经找到了所有可能的二叉树（加泰罗尼亚数）的公式，但我正在寻找完整的树。

有2^bb 位数组。有“2^b选择n”不同的方式来选择nb 位数组。我想遍历所有“2^b选择n”选择nb 位数组的不同方式。显然，这只有在现实的时间范围内才有可能，如果b和n两者都很小。

我怎么能在朱莉娅做到这一点？

我有 p 严格升序值，x0 < x1 < ... < xp

我想生成所有可能的大小为 n 的数组，其中填充了上述值 a[0] <= a[1] <= ... <= a[n-2] <= a[n-1]。例如：

[x0, x0, x0, ... , x0]
[x0, x1, x1, ... , x1]
[x0, x0, x1, ... , x1]
[x1, x2, x3, ... , x3]

etc...

这样做的最优雅和最有效的方法是什么？

我怎样才能找到两个数字的所有组合，使得两个值的总和等于tot_max <= 16（最大，允许更少）并且两者之间的比率为rat=0.5。

这样的例子是：

V1 V2 ratio(V1/V2) sum
1  2   0.5          3.   OK
2  4   0.5          6.   OK
3  6   0.5          9.   OK
4  8   0.5         12.   OK
8  16  0.5         24.   NOT OK (over 16)

这两个数字（V1 和 V2）应为大于 0 的整数。

如何创建 R 代码以便它可以容纳tot_max和的不同值rat？

对于嵌套二元组，我的意思是这样的：((a,b),(c,(d,e)))所有元组都有两个元素。我不需要元素的不同顺序，只需要在它们周围放置括号的不同方式。对于items = [a, b, c, d]，有 5 个独特的配对，它们是：

(((a,b),c),d)  
((a,(b,c)),d)  
(a,((b,c),d))  
(a,(b,(c,d)))  
((a,b),(c,d))

在完美的世界中，我还想控制返回元组的最大深度，这样如果我生成 的所有配对items = [a, b, c, d]，max_depth=2它只会返回((a,b),(c,d))。

出现这个问题是因为我想找到一种方法来生成非交换、非关联数的加法结果。如果a+b不等于b+a，且不a+(b+c)等于(a+b)+c，a、b、c 的所有可能和是多少？

我创建了一个生成所有配对的函数，但它也返回重复项。

import itertools

def all_pairings(items):
    if len(items) == 2:
        yield (*items,)
    else:
        for i, pair in enumerate(itertools.pairwise(items)):
            for pairing in all_pairings(items[:i] + [pair] + items[i+2:]):
                yield pairing

例如，它返回((a,b),(c,d))两次 for ，因为它在一种情况下将第一个配对，在第二种情况下将第一个items=[a, b, c, d]配对。(a,b)(c,d)

对于大量项目来说，返回重复项成为一个越来越大的问题。根据加泰罗尼亚数字 …

我希望最终得到一个包含 48 620 个嵌套列表的列表，其中包含不同顺序的 9 个零和 9 个一。

from itertools import permutations

print(list(permutations('000000000111111111', r=18)))

我假设上面的代码有效，但每个0and1都被视为一个单独的符号，因此对于每个排序，我都会得到大量重复：

('0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1')
('0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1')
('0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1')
('0', '0', '0', '0', '0', '0', '0', …