combinations

生成数组的所有元素组合

自 R2023a 起

全页折叠

    语法

    T = combinations(A1,...,An)

    说明

    T = combinations(A1,...,An) 生成输入数组 A1,...,An 的所有元素组合，其中输出表 T 的每行均为一个组合。这些组合与 n 组元素的笛卡尔积相同，其中 n 组由输入数组 A1,...,An 表示。

    • T 中的行数是每个输入数组中元素数的乘积。行数与组合数相同。

    • T 中的变量数目与输入数组的数目相同。

    • T 中每个变量的数据类型与对应输入数组的数据类型相同。

    示例

    示例

    全部折叠

    打开实时脚本

    生成两个向量的所有元素组合。输出表 T 的每行均为来自第一个向量的第一个元素和来自第二个向量的第二个元素的组合。变量 Var1 包含来自第一个向量的元素，变量 Var2 包含来自第二个向量的元素。

    T = combinations([1 8 6],[9 3 2])
    T=9×2 table
    Var1    Var2
    ____    ____

     1       9  
     1       3  
     1       2  
     8       9  
     8       3  
     8       2  
     6       9  
     6       3  
     6       2
    打开实时脚本

    生成两个数组的所有元素组合。combinations 函数在生成元素组合之前将每个输入重构为一个列向量。

    T = combinations([7 3;2 6],[9 1 4])
    T=12×2 table
    Var1    Var2
    ____    ____

     7       9  
     7       1  
     7       4  
     2       9  
     2       1  
     2       4  
     3       9  
     3       1  
     3       4  
     6       9  
     6       1  
     6       4
    打开实时脚本

    生成三个字符串数组的所有元素组合。输出表中变量的名称均基于字符串数组的名称。

    ID = ["A" "B" "C"];
color = ["red" "blue" "green"];
sz = ["small" "large"];

T = combinations(ID,color,sz)
    T=18×3 table
    ID      color       sz   
    ___    _______    _______

    "A"    "red"      "small"
    "A"    "red"      "large"
    "A"    "blue"     "small"
    "A"    "blue"     "large"
    "A"    "green"    "small"
    "A"    "green"    "large"
    "B"    "red"      "small"
    "B"    "red"      "large"
    "B"    "blue"     "small"
    "B"    "blue"     "large"
    "B"    "green"    "small"
    "B"    "green"    "large"
    "C"    "red"      "small"
    "C"    "red"      "large"
    "C"    "blue"     "small"
    "C"    "blue"     "large"
      ⋮

    通过对每个组合中的元素进行组合来创建数据标签。使用花括号 {} 提取表 T 的内容，并使用 join 跨行组合元素。

    labels = join(T{:,:},"_")
    labels = 18×1 string
    "A_red_small"
    "A_red_large"
    "A_blue_small"
    "A_blue_large"
    "A_green_small"
    "A_green_large"
    "B_red_small"
    "B_red_large"
    "B_blue_small"
    "B_blue_large"
    "B_green_small"
    "B_green_large"
    "C_red_small"
    "C_red_large"
    "C_blue_small"
    "C_blue_large"
    "C_green_small"
    "C_green_large"
    打开实时脚本

    生成不同大小和数据类型的输入的所有元素组合。

    输出表 T 中的行数等于 numel(A1)、numel(A2) 和 numel(A3) 的乘积。输出表 T 中每个变量的数据类型与对应输入的数据类型相同。

    A1 = [0 1; 2 3];
A2 = ["a" "b" "c"];
A3 = categorical(["x" "y"]);
T = combinations(A1,A2,A3)
    T=24×3 table
    A1    A2     A3
    __    ___    __

    0     "a"    x 
    0     "a"    y 
    0     "b"    x 
    0     "b"    y 
    0     "c"    x 
    0     "c"    y 
    2     "a"    x 
    2     "a"    y 
    2     "b"    x 
    2     "b"    y 
    2     "c"    x 
    2     "c"    y 
    1     "a"    x 
    1     "a"    y 
    1     "b"    x 
    1     "b"    y 
      ⋮

    输入参数

    全部折叠

    输入数组，指定为标量、向量、矩阵或多维数组的以逗号分隔的列表。输入数组可以有不同大小和数据类型。

    数据类型: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char | string | struct | datetime | duration | calendarDuration | categorical | cell
    复数支持: 是

    提示

    • 分类数组

      如果您的输入数组是分类数组，您可能希望生成另一个分类数组，其类别是输入的所有组合。由于 combinations 函数返回表中的所有组合，请考虑改用 .* 运算符。

      例如，创建两个分类数组并调用 .* 运算符。

      colors = categorical(["blue" "red" "green" "black"]);
signs = categorical(["+" "-" "-" "+"]);
C = colors .* signs

      C = 

  1×4 categorical array

     blue +      red -      green -      black +

      结果是一个分类数组，其类别是输入的类别的所有组合。使用 categories 函数列出类别。

      categories(C)

      ans =

  8×1 cell array

    {'black +'}
    {'black -'}
    {'blue +' }
    {'blue -' }
    {'green +'}
    {'green -'}
    {'red +'  }
    {'red -'  }

    版本历史记录

    在 R2023a 中推出

    另请参阅

    | | | | |

    主题