Python 根据替换组合计算柱的乘积 问题

这有点难以解释，但我会尽力的。我知道用置换法求组合数的方程式。假设我有6个向量：A，B，C，D，E，F。如果我想找到这6个变量的每一个可能的立方积，它应该是（6+3-1）/3.(6-1)! = 56种组合（见末尾）。类似地，如果我想要每个二次积，它是21。对于线性，当然是6（每个变量本身）。我想计算所有6+21+56=83个组合。我考虑了3个循环，每个内部循环从它的外部循环开始迭代

for i1=1:6
   X(:,?) = X.*X(:,i1)
   for i2=i1:6
      X(:,?) = X.*X(:,i2)
      for i3=i2:6
         X(:,?) = X.*X(:,i3)

但将83列矩阵的索引存储在左侧的所有数据让我感到困惑。正如你所看到的，它们都标有问号

PS：可能也需要在第五顺序中这样做，这样它将添加另外126列和252列，总共461列。所以，一个更通用的代码是更好的，而不是硬代码三阶。但如果硬编码为5，那没关系，因为我绝对不会超过这个数字

MATLAB或Python都可以，因为我可以很容易地在两者之间切换

二次组合的实例计算 下面是我希望在Excel中完成的6个变量（A到F）的二次组合的21列示例。我为每个向量采集了3个样本。

立方组合表 以下是我需要计算的56种组合：

A、 A，A

A、 A，B

A、 A，C

A、 A，D

A、 A，E

A、 A，F

A、 B，B

A、 B，C

A、 B，D

A、 B，E

A、 B，F

A、 C，C

A、 C，D

A、 C，E

A、 C，F

A、 D，D

A、 D，E

A、 D，F

A、 E，E

A、 E，F

A、 F，F

B、 B，B

B、 B，C

B、 B，D

B、 B，E

B、 B，F

B、 C，C

B、 C，D

B、 C，E

B、 C，F

B、 D，D

B、 D，E

B、 D，F

B、 E，E

B、 E，F

B、 F，F

C、 C，C

C、 C，D

C、 C，E

C、 C，F

C、 D，D

C、 D，E

C、 D，F

C、 E，E

C、 E，F

C、 F，F

D、 D，D

D、 D，E

D、 D，F

D、 E，E

D、 E，F

D、 F，F

E、 E，E

E、 E，F

E、 F，F

---

F、 F，F

使用计数器可以避免索引混乱：

clear all; close all

% Original matrix
M = [
   2 2 3 2 8 8;
   5 1 7 9 4 4;
   4 1 2 7 2 9
];

% Number of combinations
order = 3;
sizeX = nchoosek(size(M,2)+order-1,order);

% Combinations
imat = ones(sizeX,order);
for c=2:sizeX
    imat(c,:) = imat(c-1,:);
    for o=order:-1:1
        if (imat(c-1,o)<size(M,2))
            imat(c,o:end) = imat(c-1,o)+1;
            break
        end
    end
end

% Transpose & display combinations
imat = transpose(imat)

% Computations of products
X = ones(size(M,1),sizeX);
for o=1:order
    X = X.*M(:,imat(o,:));
end

% Display result
X

---

我测试了它的顺序=4，它应该可以工作。

这是Matlab中的矢量化方法。它应该很快，但内存效率不高，因为它生成列索引的所有笛卡尔元组，然后只保留非递减的元组

x=[223288；51794；412729]；%数据
P=2；%产品订单
ind=细胞（1，P）；
[ind{end:-1:1}]=ndgrid（1:size（x，2））；%P阶列指数的笛卡尔幂
ind=重塑（cat（P+1，ind{:}），[]，P）；%二维数组，其中每个笛卡尔元组是一行
ind=ind（全部（diff（ind，[]，2）>=0，2），：）；%仅保留非递减行
结果=产品（重塑（x（：，索引），尺寸（x，1），P，[]），2）；%将索引应用到数据中。这
%创建中间三维阵列。计算产品
结果=排列（结果[1 3 2]）；%转换为二维阵列

为什么

ABA

、

ACA

等等不在列表中？@Sushanth是组合，而不是排列。所以ABA和ACA已经被计算在AAB和AAC中了。既然如此，为什么不使用内置语言呢？你能添加一个具有精确输入和输出的小示例吗，这样我们就可以更好地了解你想要什么了？另外，你可以用这两种标记语言中的任何一种来解决问题吗？非常感谢。我现在不太在乎内存，因为我不会在超大数据上使用它。最多20-30个向量，在这种情况下，我可能会减少顺序。现在我将尝试将其迁移到Python。看起来像是标准函数，所以我觉得应该很简单。排列的作用是什么，[1 3 2]是特定于订单2还是与任何订单一起工作？

permute

更改维度的顺序（而不是其关联的大小）。这是矩阵转置的推广。它的第二个论点是一般性的，而不仅仅是针对二阶情形。我认为它的Numpy等价物可能是，但我不擅长Python/NumpyThanks来澄清这个问题！这是有道理的。我会在这里发布Python的答案，如果/当我让它工作起来的时候，但是这做的很好，所以我很高兴：）@ZackFair我很高兴@ZackFair你是对的，它应该是

P

（或任何大于该值的值），而不是

3

。谢谢你抓住了！编辑。我改为

P+1

，而不是

P

，因为我认为这样更清晰（将所有

P

-dim数组沿下一个dim堆叠），我认为这里可能有一些小错误，因为最后4行（EEE，EEF，EFF，FFF）的前两行分别为512，64，然后是8，36，162，729，当我使用下面的Luis代码时，我得到了这些。这就是为什么我选择这个作为正确答案的原因，因为它也适用于任何顺序。不过还是要谢谢你！对不起，我不明白出了什么问题，

2^3=8

，

5^3=125

和

4^3=64

没有错。也许我不理解你的问题或你的评论。看起来您找到了问题的解决方案，因此主要问题；）你是对的，我的错。我使用了示例代码，没有过多关注结果。所有乘法必须在三个FOR循环内完成。我编辑了答案，谢谢你的反馈！是的，矩阵形式肯定更快。我试图尊重您的原始代码，因为您对索引感到困惑，我不想完全改变您的解决方案。我还不明白顺序是一个参数。我将为您编辑代码。无论原始矩阵和顺序如何，它现在都应该可以完成这项工作。对于这个问题，计算并不是很重，内存消耗可能是个大问题。祝你下次好运！

>> test_script
imat =
  Columns 1 through 16
     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1     1
     1     1     1     1     1     1     2     2     2     2     2     3     3     3     3     4
     1     2     3     4     5     6     2     3     4     5     6     3     4     5     6     4
  Columns 17 through 32
     1     1     1     1     1     2     2     2     2     2     2     2     2     2     2     2
     4     4     5     5     6     2     2     2     2     2     3     3     3     3     4     4
     5     6     5     6     6     2     3     4     5     6     3     4     5     6     4     5
  Columns 33 through 48
     2     2     2     2     3     3     3     3     3     3     3     3     3     3     4     4
     4     5     5     6     3     3     3     3     4     4     4     5     5     6     4     4
     6     5     6     6     3     4     5     6     4     5     6     5     6     6     4     5
  Columns 49 through 56
     4     4     4     4     5     5     5     6
     4     5     5     6     5     5     6     6
     6     5     6     6     5     6     6     6

X =
  Columns 1 through 16
     8     8    12     8    32    32     8    12     8    32    32    18    12    48    48     8
   125    25   175   225   100   100     5    35    45    20    20   245   315   140   140   405
    64    16    32   112    32   144     4     8    28     8    36    16    56    16    72   196
  Columns 17 through 32
    32    32   128   128   128     8    12     8    32    32    18    12    48    48     8    32
   180   180    80    80    80     1     7     9     4     4    49    63    28    28    81    36
    56   252    16    72   324     1     2     7     2     9     4    14     4    18    49    14
  Columns 33 through 48
    32   128   128   128    27    18    72    72    12    48    48   192   192   192     8    32
    36    16    16    16   343   441   196   196   567   252   252   112   112   112   729   324
    63     4    18    81     8    28     8    36    98    28   126     8    36   162   343    98
  Columns 49 through 56
    32   128   128   128   512   512   512   512
   324   144   144   144    64    64    64    64
   441    28   126   567     8    36   162   729