Javascript 从1个列表生成2个组合的算法

我需要一个算法，将生成2个列表的3个字符从一个列表的6。例如，我有一个包含

[a，b，c，d，e，f]

的数组，我想创建组合，例如

[a，b，c][d，e，f]

我需要得到2乘以3个字符的所有可能组合

约束

• 两种组合不可能是相同的。我的意思是，我不能有2倍相同的3个字符在一起，在不同的顺序。因此，如果已经生成了

  [a，b，c][d，e，f]

  ，我不能将

  [b，a，c][f，d，e]

  作为另一种可能性或

  [f，d，e][b，a，c]

---

理想情况下，我希望该算法是用javascript编写的，但我愿意接受任何其他建议（我可以阅读代码，即使我不懂该语言，我也很可能能够用我不懂的语言理解该算法）。我看了很多关于排列和组合的帖子和问题，但似乎没有一篇是我想要的，我似乎不知道如何修改它们以适应我想要的。

尝试将树和队列/堆栈数据结构相结合来实现这种行为。

---

与树遍历相关的算法应该很简单。

给定一个包含元素

{1，…，6}

的输入集，您需要1。生成

{2，…，6}

和2的所有不同3-子集。计算每个子集与输入集的交集（余数）：

函数*子集（输入、长度、开始=0）{
如果（开始>=input.length | | length<1）产生[新集合（），新集合（输入）]；
否则{
对于（让i=start；i我可以想到的暴力解决方案：-

第一个位置可以有6个选项中的任意一个。
第二个位置可以有五分之一
第三个可以有四分之一

剩下的3个会在另一个列表中。所以基本上需要做的是：-

继续生成所有3种大小的组合，并将它们放入哈希映射。生成新组合时，检查它是否存在于映射中。如果存在，则跳过它，否则将其添加到映射中。有效的方法可能是存储组合的排序顺序

希望这有帮助！！
很简单：

迭代
{2，…，6}
的所有2-子集，例如使用回溯
对于每个子集<代码> s>代码>，考虑<代码> H1= S⋃ {1} 

，

H2={1，…，6}∖ H1

当前组合包括

A

中的项目（由

H1

中的索引给出）和

A

中的项目（由

H2

索引给出）

因为这强制执行

1∈ H1

，您将不会获得类似于

[a，b，c][d，e，f]

，

[d，e，f][a，b，c]

的重复

---

因为套路没有顺序，所以你不会获得重复的动作，比如

[a，b，c][d，e，f]

，

[b，a，c][f，d，e]

，为了避免

[a，b，c]

[a，c，b]重复，从“a”到“d”，从第一个玩家后面的第二个玩家选到“e”，从第二个玩家后面的第三个玩家选到“f”

为避免重复，请将球员“a”留在一线队

这是最简单的代码：（它为一个团队挑选人员；第二个团队显然由其他3人组成）

函数分布（n）{
对于（变量i=1；i<5；i++）{
对于（var j=i+1；j<6；j++）{
文件。编写（“第1组：“+n[0]+”、“+n[i]+”、“+n[j]+”
”）；
}
}
}
分发（[“a”、“b”、“c”、“d”、“e”、“f”）；

在这个问题上需要注意的主要问题是：我们不需要构建第二个包含三项的列表，一旦我们构建了包含三项的第一个列表，第二个列表就是第一个列表的补充

示例：

假设我们选择3个项目作为

[a，b，c]

，第二个列表就是

[a，b，c，d，e，f]

-

[a，b，c]

=

[d，e，f]

因此，我们将只关注第一个列表（列表1）

让我们关注任何单个元素，例如

a

（任意选取）。我们观察到：

在两个列表中，每一个可能的组合都将始终有

a

作为某个列表的成员，无论哪个列表包含

a

，让我们称之为列表1。让我们选择

列表1

的其他成员

我们选择了第一个成员。第二个成员可以从

[b、c、d、e、f]

中选择

在算法的第一次迭代中，我们将选择第二个成员作为

b

。第三个成员可以有四个可能性。这意味着我们必须从

[c，d，e，f]中选择一个元素

。一旦我们选择了第三个成员，我们的

列表1

就完成了，

列表2

也完成了。当第三个成员考虑了所有4种可能性后，第一次迭代就完成了

在算法的第二次迭代中，我们将选择第二个成员作为

c

。现在第三个成员只能有3种可能性，而不能4，因为我们已经考虑了b。这三种可能性将是

[d，e，f]

。一旦我们选择了第三个成员，我们的

列表1

就完成了，

列表2

也完成了。当第三个成员考虑了所有3种可能性后，第二次迭代就完成了

类似地，在第三次迭代中，我们的第二个成员将是

d

，第三个成员

[e，f]

将有两种可能性

类似地，在第四次迭代中，我们的第二个成员将是

e

，第三个成员只有一种可能性，即

f

注意

我们不必担心我们的算法将有多少次迭代，我们的算法的终止条件将是possib的总数

Initialize an array of character of length 6 namely set = [a , b , c , d , e , f]

Initialize an array of integer(or boolean to save space cause we will be storing only 0 
and 1) of length 6 namely arr,initialized to 0.

int x = 10, total = 0,i = 1.
arr[0] = 1// because element a belongs to list 1

while(total < x)
{
 arr[i] = 1

 for(j = i + 1 to 5)
 {
  arr[j] = 1
  list 1 is made of all elements set[k] such that arr[k] = 1
  list 2 is made of all elements set[k] such that arr[k] = 0
  arr[j] = 0
 }

 total = total + 5 - i 
 arr[i] = 0
 i = i + 1
}