Arrays 如何仅组合向量-Matlab

如何在Matlab中将所有向量组合成向量的小子集

a= [5 6 7] b = [8 9 10] c=[11 12 13] d=[14 15 16] e=[17 18 19]

a与b和c的组合：

结果：

M1= [ 5 6 7 8 9 10 11 12 13]

a带b和d：

M2 = [5 6 7 8 9 10 14 15 16]

---

依此类推……

您可以使用

cat

功能：

res = cat(2,a,b,c);

或者简单地使用

[]

语法：

res = [a b c];

在这两种情况下，

res

将包含

[5 6 7 8 9 10 11 12 13]

---

最好，您可以使用

cat

功能：

res = cat(2,a,b,c);

或者简单地使用

[]

语法：

res = [a b c];

在这两种情况下，

res

将包含

[5 6 7 8 9 10 11 12 13]

---

最好，您可以使用

cat

功能：

res = cat(2,a,b,c);

或者简单地使用

[]

语法：

res = [a b c];

在这两种情况下，

res

将包含

[5 6 7 8 9 10 11 12 13]

---

最好，您可以使用

cat

功能：

res = cat(2,a,b,c);

或者简单地使用

[]

语法：

res = [a b c];

在这两种情况下，

res

将包含

[5 6 7 8 9 10 11 12 13]

---

最好的答案是，这个答案涵盖了任意数量的向量的情况。这些向量被假定为等长的行向量

让您的示例数据定义为

a = [5 6 7]; b = [8 9 10]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
vectors = {a, b, c, d, e}; %// cell array with any number of row vectors of equal size
n = 3; %// desired subset size

然后：生成所有索引组合，使用该组合将其索引为

向量

，连接为一个大行向量，并对其进行整形以获得所需结果：

combs = nchoosek(1:numel(vectors), n);
result = reshape([vectors{combs.'}], numel(vectors{1})*n, []).';

这给出了一个矩阵，其第一行是您的

M1

，第二行是

M2

等：

result =
     5     6     7     8     9    10    11    12    13
     5     6     7     8     9    10    14    15    16
     5     6     7     8     9    10    17    18    19
     5     6     7    11    12    13    14    15    16
     5     6     7    11    12    13    17    18    19
     5     6     7    14    15    16    17    18    19
     8     9    10    11    12    13    14    15    16
     8     9    10    11    12    13    17    18    19
     8     9    10    14    15    16    17    18    19
    11    12    13    14    15    16    17    18    19

---

这个答案涵盖了任意数量的向量的情况。这些向量被假定为等长的行向量

让您的示例数据定义为

a = [5 6 7]; b = [8 9 10]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
vectors = {a, b, c, d, e}; %// cell array with any number of row vectors of equal size
n = 3; %// desired subset size

然后：生成所有索引组合，使用该组合将其索引为

向量

，连接为一个大行向量，并对其进行整形以获得所需结果：

combs = nchoosek(1:numel(vectors), n);
result = reshape([vectors{combs.'}], numel(vectors{1})*n, []).';

这给出了一个矩阵，其第一行是您的

M1

，第二行是

M2

等：

result =
     5     6     7     8     9    10    11    12    13
     5     6     7     8     9    10    14    15    16
     5     6     7     8     9    10    17    18    19
     5     6     7    11    12    13    14    15    16
     5     6     7    11    12    13    17    18    19
     5     6     7    14    15    16    17    18    19
     8     9    10    11    12    13    14    15    16
     8     9    10    11    12    13    17    18    19
     8     9    10    14    15    16    17    18    19
    11    12    13    14    15    16    17    18    19

---

这个答案涵盖了任意数量的向量的情况。这些向量被假定为等长的行向量

让您的示例数据定义为

a = [5 6 7]; b = [8 9 10]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
vectors = {a, b, c, d, e}; %// cell array with any number of row vectors of equal size
n = 3; %// desired subset size

然后：生成所有索引组合，使用该组合将其索引为

向量

，连接为一个大行向量，并对其进行整形以获得所需结果：

combs = nchoosek(1:numel(vectors), n);
result = reshape([vectors{combs.'}], numel(vectors{1})*n, []).';

这给出了一个矩阵，其第一行是您的

M1

，第二行是

M2

等：

result =
     5     6     7     8     9    10    11    12    13
     5     6     7     8     9    10    14    15    16
     5     6     7     8     9    10    17    18    19
     5     6     7    11    12    13    14    15    16
     5     6     7    11    12    13    17    18    19
     5     6     7    14    15    16    17    18    19
     8     9    10    11    12    13    14    15    16
     8     9    10    11    12    13    17    18    19
     8     9    10    14    15    16    17    18    19
    11    12    13    14    15    16    17    18    19

---

这个答案涵盖了任意数量的向量的情况。这些向量被假定为等长的行向量

让您的示例数据定义为

a = [5 6 7]; b = [8 9 10]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
vectors = {a, b, c, d, e}; %// cell array with any number of row vectors of equal size
n = 3; %// desired subset size

然后：生成所有索引组合，使用该组合将其索引为

向量

，连接为一个大行向量，并对其进行整形以获得所需结果：

combs = nchoosek(1:numel(vectors), n);
result = reshape([vectors{combs.'}], numel(vectors{1})*n, []).';

这给出了一个矩阵，其第一行是您的

M1

，第二行是

M2

等：

result =
     5     6     7     8     9    10    11    12    13
     5     6     7     8     9    10    14    15    16
     5     6     7     8     9    10    17    18    19
     5     6     7    11    12    13    14    15    16
     5     6     7    11    12    13    17    18    19
     5     6     7    14    15    16    17    18    19
     8     9    10    11    12    13    14    15    16
     8     9    10    11    12    13    17    18    19
     8     9    10    14    15    16    17    18    19
    11    12    13    14    15    16    17    18    19

---

使用

nchoosek

a = [5 6 7]; b = [8 9]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
N = 3;
x = {a,b,c,d,e};
y = nchoosek(x,N);

在一个单元格数组中，一次获取所有数组的组合

N

。单元格

x

的每一行

i

都是一个组合，因此要将其作为行向量返回，只需执行以下操作

horzcat(y{i,:})

或者，如果您想将它们全部获取并放入大小为

n_combs

n_combs = size(y,1);
out = cell(0,n_combs);
for i = 1 : n_combs
    out{i} = horzcat(1, y{i,:});
end

对要组合的阵列的大小没有限制，例如，可以组合

a = [5 7]; b = [8 9]; c = [11]; d = [20 14 15 16]; e = [17 18 19];

但是，如果必须将所有组合放在一个矩阵中，那么数组的大小必须相同。在这种情况下，路易斯·门多的回答起了作用

---

最后，如果允许重复，请使用而不是

nchoosek

使用

nchoosek

a = [5 6 7]; b = [8 9]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
N = 3;
x = {a,b,c,d,e};
y = nchoosek(x,N);

在一个单元格数组中，一次获取所有数组的组合

N

。单元格

x

的每一行

i

都是一个组合，因此要将其作为行向量返回，只需执行以下操作

horzcat(y{i,:})

或者，如果您想将它们全部获取并放入大小为

n_combs

n_combs = size(y,1);
out = cell(0,n_combs);
for i = 1 : n_combs
    out{i} = horzcat(1, y{i,:});
end

对要组合的阵列的大小没有限制，例如，可以组合

a = [5 7]; b = [8 9]; c = [11]; d = [20 14 15 16]; e = [17 18 19];

但是，如果必须将所有组合放在一个矩阵中，那么数组的大小必须相同。在这种情况下，路易斯·门多的回答起了作用

---

最后，如果允许重复，请使用而不是

nchoosek

使用

nchoosek

a = [5 6 7]; b = [8 9]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
N = 3;
x = {a,b,c,d,e};
y = nchoosek(x,N);

在一个单元格数组中，一次获取所有数组的组合

N

。单元格

x

的每一行

i

都是一个组合，因此要将其作为行向量返回，只需执行以下操作

horzcat(y{i,:})

或者，如果您想将它们全部获取并放入大小为

n_combs

n_combs = size(y,1);
out = cell(0,n_combs);
for i = 1 : n_combs
    out{i} = horzcat(1, y{i,:});
end

对要组合的阵列的大小没有限制，例如，可以组合

a = [5 7]; b = [8 9]; c = [11]; d = [20 14 15 16]; e = [17 18 19];

但是，如果必须将所有组合放在一个矩阵中，那么数组的大小必须相同。在这种情况下，路易斯·门多的回答起了作用

---

最后，如果允许重复，请使用而不是

nchoosek

使用

nchoosek

a = [5 6 7]; b = [8 9]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
N = 3;
x = {a,b,c,d,e};
y = nchoosek(x,N);

在一个单元格数组中，一次获取所有数组的组合

N

。单元格

x

的每一行

i

都是一个组合，因此要将其作为行向量返回，只需执行以下操作

horzcat(y{i,:})

或者，如果您想将它们全部获取并放入大小为

n_combs

n_combs = size(y,1);
out = cell(0,n_combs);
for i = 1 : n_combs
    out{i} = horzcat(1, y{i,:});
end

对要组合的阵列的大小没有限制，例如，可以组合

a = [5 7]; b = [8 9]; c = [11]; d = [20 14 15 16]; e = [17 18 19];

但是，如果必须将所有组合放在一个矩阵中，那么数组的大小必须相同。在这种情况下，路易斯·门多的回答起了作用

---

最后，如果允许重复使用而不是使用

nchoosek

那么，以3人一组的方式进行组合而不重复？所有长度都是3的向量吗？那么，以3为一组进行组合，不重复？所有长度都是3的向量吗？那么，以3为一组进行组合，不重复？所有长度都是3的向量吗？那么，以3为一组进行组合，不重复？都好吗

a = [5 6 7]; b = [8 9]; c = [11 12 13]; d = [14 15 16]; e = [17 18 19];
N = 3;
x = {a,b,c,d,e};
y = nchoosek(x,N);