C# 在两个数组之间查找所有可能的值组合

我有两个字符串数组，长度不一定相同，我想从数组中找到两个值之间所有可能的组合“集合”，而不从任何一个数组中重复。
例如，给定数组：
{“A1”、“A2”、“A3”}
{“B1”，“B2”}
我想要的结果是以下几组：
{（“A1”、“B1”），（“A2”、“B2”）}
{（“A1”、“B1”），（“A3”、“B2”）}
{（“A1”、“B2”），（“A2”、“B1”）}
{（“A1”、“B2”），（“A3”、“B1”）}
{（“A2”、“B1”），（“A3”、“B2”）}
{（“A2”，“B2”），（“A3”，“B1”）}

我的主要方向是创建递归函数，该函数将两个数组作为参数，并一次删除每个“选定”字符串，调用自身直到其中一个数组为空，但是我有点担心性能问题（我需要在大约1000对字符串数组上运行此代码）。

---

有人能告诉我一个有效的方法来做这件事吗？

这不是完全相同的问题，但我对以下问题做了一个解决方案，这可能是一个不错的起点：

---

将两个数组视为一张表的侧面可能是有益的：

        A1      A2      A3
---+-------+-------+-------+
B1 | B1,A1 | B1,A2 | B1,A3 |
---+-------+-------+-------+
B2 | B2,A1 | B2,A2 | B2,A3 |
---+-------+-------+-------+

这意味着一个嵌套在另一个循环中的循环，一个用于行，另一个用于列。这将为您提供初始对集：

{B1,A1} {B1,A2} {B1,A3} {B2,A1} {B2,A2} {B2,A3}

然后是建立初始集合的组合的问题。您可以使用行和列的一组对，以类似方式可视化组合：

      B1,A1 B1,A2 B1,A3 B2,A1 B2,A2 B2,A3
-----+-----+-----+-----+-----+-----+-----+
B1,A1|     |  X  |  X  |  X  |  X  |  X  |
-----+-----+-----+-----+-----+-----+-----+
B1,A2|     |     |  X  |  X  |  X  |  X  |
-----+-----+-----+-----+-----+-----+-----+
B1,A3|     |     |     |  X  |  X  |  X  |
-----+-----+-----+-----+-----+-----+-----+
B2,A1|     |     |     |     |  X  |  X  |
-----+-----+-----+-----+-----+-----+-----+
B2,A2|     |     |     |     |     |  X  |
-----+-----+-----+-----+-----+-----+-----+
B2,A3|     |     |     |     |     |     |
-----+-----+-----+-----+-----+-----+-----+

---

同样，这可以通过一对嵌套循环来实现（提示：内部循环的范围将由外部循环的值决定）。

关于此站点上两个列表的组合，有很多问题（和答案）（请参见侧栏）。如果我理解正确，您的用例看起来只是表面上的不同

有一个方法就够了吗

IEnumerable<Tuple<string, string>> Combinations(
  IEnumerable<string> list1, 
  IEnumerable<string> list2) {}

IEnumerable组合(
IEnumerable列表1，
IEnumerable list2）{}

（已存在于“副本”中的各种形式和大小），然后通过以下步骤使用（家庭作业=填写详细信息）：

迭代列表1和列表2的所有组合（使用类似于上面的内容）和

• 按当前组合的第一个元素筛选列表1
• 按当前组合的第二个元素筛选列表2
• 将当前组合与筛选列表的所有可能组合相结合（使用类似于上述方法的方法）
非常简单的方法是

string[] arr = new string[3];
        string[] arr1 = new string[4];
        string[] jointarr = new string[100];

        for (int i = 0; i < arr.Length; i++)
        {
            arr[i] = "A" + (i + 1);
        }

        for (int i = 0; i < arr1.Length; i++)
        {
            arr1[i] = "B" + (i + 1);
        }

        int k=0;
        for (int i = 0; i < arr.Length; i++)
        {
            for (int j = 0; j < arr1.Length; j++)
            {
                jointarr[k] = arr[i] + " " + arr1[j];
                k++;
            }
        }

string[]arr=新字符串[3]；
字符串[]arr1=新字符串[4]；
字符串[]jointarr=新字符串[100]；
对于（int i=0；i

如果我正确理解了您的问题，所有组合都可以通过以下方式导出：
• 从A中选择两个不同的元素{A_i，A_j}
• 从B中选择了两个不同的元素

  {B_k，B_l}

• 用这些元素做两个组合

  {（A_i，B_k），（A_j，B_l）}，{（A_i，B_l），（A_j，B_k）}

对于A和B中2个元素子集的所有组合，您可以得到所需的所有组合
有

|A |*（|A |-1）*|B |*（|B |-1）/2个组合

Easies实现有4个循环：

for i = 1 ... |A|
  for j = i+1 ... |A|
    for k = 1 ... |B|
      for l = k+1 ... |B|
        make 2 combinations {(A_i, B_k),(A_j, B_l)}, {(A_i, B_l), (A_j, B_k)}

您的问题相当于以下问题：

问题陈述：

给定大小为
n
的两个向量
A
，
B
大小为
m
，其中
nm。生成对时交换回。
布尔交换=假；
如果（n>m）{
交换=真；
交换（n，m）；
}
//现在n小于或等于m
矢量A=发电机阵列（n）；
矢量B=发电机轨道（m）；
向量匹配；
//生成m的所有置换
做{
矢量匹配；
对于（int i=0；i
当我看到一个纵横字谜式的拼图，其中每个方块都有一个数字，你必须找出哪个字母对应哪个数字，才能使单词正确。知道我已经给出了答案，我将尝试总结问题，并展示如何递归地解决它

在x字的情况下，较小的数组A是一系列数字，较大的数组B包含字母表中的字母。问题是将每个数字分配给一个字母，并找到所有可能的组合。一般来说，我们有：

A={1,2,...m} and B={1,2,....n}     n>=m

每个可能的结果都可以写成一个包含m个元素的数组C，其中元素i带有值j，对应于对A（i）B（j）。排列的总数，即C数组，是n（n-1）…（n-m+1）或更简洁地写：n/（m+1）

这个数字源于这样的想法：当A的第一个元素与B中的任何元素配对时，A的第二个元素可以与除第一个元素所取元素之外的任何元素配对，依此类推

我们可以通过以下伪代码来实现这一点：

for i= 1 to n
   C(1)=B(i)
   for j= 1 to n-1
      C(2)=B'(j)        '  B' is B with element i removed
         .........
          for x = 1 to n-m
             C(m)=B'''(x)   'B is now reduced with (m-1) elements
          next x

为了直观，我使用基于1的数组

此代码不适用于arbi
for i= 1 to n
   C(1)=B(i)
   for j= 1 to n-1
      C(2)=B'(j)        '  B' is B with element i removed
         .........
          for x = 1 to n-m
             C(m)=B'''(x)   'B is now reduced with (m-1) elements
          next x

   AllPairs (A,B,C)
    if Size(A)>1             ' check no of elements in A        
      for i=1 to Size(B)
       C(Size(C)-Size(A)+1)= B(i)
       A'=Remove element 1 from A
       B'=Remove element i from B
       Call AllPairs(A',B',C)     'recursive call
      Next i
    else                          ' only one element in A
      for j=1 to Size(B)
      C(Size(C)) = B(i)  'looping last element in C through all unused in B
      Collect.ADD(C)      'collect C-arrays here for later use
      Next j                 
  End AllPairs