Question

说我有以下数组：

var arr = new[] { "A", "B", "C" };

如何生成仅包含两个字符且两个字符不相同的所有可能组合（例如AB与BA相同）。例如，使用上面的数组会产生：

AB
AC
BC

请注意，此示例已简化。数组和所需字符串的长度将更长。

如果有人可以提供帮助，我真的很感激。

Answer 1

让我们扩展它，所以也许我们可以看到模式：

string[] arr = new string[] { "A", "B", "C", "D", "E" };

//arr[0] + arr[1] = AB
//arr[0] + arr[2] = AC
//arr[0] + arr[3] = AD
//arr[0] + arr[4] = AE

//arr[1] + arr[2] = BC
//arr[1] + arr[3] = BD
//arr[1] + arr[4] = BE

//arr[2] + arr[3] = CD
//arr[2] + arr[4] = CE

//arr[3] + arr[4] = DE

我在这里看到两个循环。

第一个（外部）循环从0到3（arr.Length - 1）
第二个（内部）循环从外循环计数器+ 1到4（arr.Length）

现在应该很容易将其翻译成代码！

Answer 2

这些应该给你一个起点：
http://www.interact-sw.co.uk/iangblog/2004/09/16/permuterate
http://www.codeproject.com/KB/recipes/Combinatorics.aspx

Answer 3

由于排序无关紧要，因此这些实际上是组合而非排列。在任何情况下，都有一些示例代码here（您需要标题为“组合（即没有重复）”的部分。

Answer 4

你要求的是组合，而不是排列（后一个术语暗示顺序很重要）。无论如何，它是递归的经典用法。在伪代码中：

def combs(thearray, arraylen, currentindex, comblen):
  # none if there aren't at least comblen items left,
  # or comblen has gone <= 0
  if comblen > arraylen - currentindex or comblen <= 0:
    return
  # just 1 if there exactly comblen items left
  if comblen == arraylen - currentindex:
    yield thearray[currentindex:]
    return
  # else, all combs with the current item...:
  for acomb in combs(thearray, arraylen, currentindex+1, comblen-1):
    yield thearray[currentindex] + acomb
  # ...plus all combs without it:
  for acomb in combs(thearray, arraylen, currentindex+1, comblen):
    yield acomb

Answer 5

public string[] Permute(char[] characters)
{
    List<string> strings = new List<string>();
    for (int i = 0; i < characters.Length; i++)
    {
        for (int j = i + 1; j < characters.Length; j++)
        {
            strings.Add(new String(new char[] { characters[i], characters[j] }));
        }
    }

    return strings.ToArray();
}

Answer 6

它是1到n-1或n（n-1）/ 2的总和。

int num = n * ( n - 1 ) / 2;

显然你可以使用一对因子来推广n *（n - 1），无论你想做什么（字符串大小）。

Answer 7

没有经过测试而不是最快，但是：

IEnumerable<String> Combine(String text, IEnumerable<String> strings)
{
    return strings.Select(s => text + s).Concat(Combine(strins.Take(1).First(), strings.Skip(1))
}

呼叫：

foreach (var s in Combine("" , arrayOfStrings))
{
     // print s
}

Answer 8

写了一个问题的答案，结果被标记为重复，指向此处。

var arr = new[] { "A", "B", "C" };

var arr2 = arr1.SelectMany(
    x => arr1.Select(
        y => x + y));

在VS2013中枚举到控制台时生成正确的输出。 SelectMany将展平内部IEnumerable生成的内部Select。

Answer 9

您正在寻找的是沿着以下伪代码行的双循环。

for(int i = FirstElement; i<= LastElement; increment i) {
    for(j = i; j<= lastElement; increment j) {
        if(i != j) {
            print (i, j)
        }
    }
}

获取阵列中的所有组合

9 个答案: