我有一个问题类似，但不完全相同，到了一个回答here.如何生成在.NET列表<T>的要素4.0
我想一个函数生成所有的ķ的组合来自n个元素列表的元素组合。请注意，我正在寻找组合，而不是置换，并且我们需要一个用于变化的解决方案（即，对循环进行硬编码是一种否定的）。
我在寻找一个解决方案，它是a）优雅的，b）可以在VB10/.Net 4.0中编码。
这意味着a）需要LINQ的解决方案是可以的，b）那些使用C＃“yield”命令的解决方案不是。
如果两者存在冲突，那么组合的顺序并不重要（即，词典编码，格雷码，你有什么），优雅则优于性能。
（OCaml的和C＃的解决方案here将是完美的，如果他们能在VB10进行编码。）
代码产生组合的列表作为ķ元件阵列：
public static class ListExtensions
{
public static IEnumerable<T[]> Combinations<T>(this IEnumerable<T> elements, int k)
{
List<T[]> result = new List<T[]>();
if (k == 0)
{
// single combination: empty set
result.Add(new T[0]);
}
else
{
int current = 1;
foreach (T element in elements)
{
// combine each element with (k - 1)-combinations of subsequent elements
result.AddRange(elements
.Skip(current++)
.Combinations(k - 1)
.Select(combination => (new T[] { element }).Concat(combination).ToArray())
);
}
}
return result;
}
}
集合初始化语法这里使用的是在VB 2010（source）可用。
我试图创建一个可以在VB中完成此任务的枚举。这是结果：
Public Class CombinationEnumerable(Of T)
Implements IEnumerable(Of List(Of T))
Private m_Enumerator As CombinationEnumerator
Public Sub New(ByVal values As List(Of T), ByVal length As Integer)
m_Enumerator = New CombinationEnumerator(values, length)
End Sub
Public Function GetEnumerator() As System.Collections.Generic.IEnumerator(Of List(Of T)) Implements System.Collections.Generic.IEnumerable(Of List(Of T)).GetEnumerator
Return m_Enumerator
End Function
Private Function GetEnumerator1() As System.Collections.IEnumerator Implements System.Collections.IEnumerable.GetEnumerator
Return m_Enumerator
End Function
Private Class CombinationEnumerator
Implements IEnumerator(Of List(Of T))
Private ReadOnly m_List As List(Of T)
Private ReadOnly m_Length As Integer
''//The positions that form the current combination
Private m_Positions As List(Of Integer)
''//The index in m_Positions that we are currently moving
Private m_CurrentIndex As Integer
Private m_Finished As Boolean
Public Sub New(ByVal list As List(Of T), ByVal length As Integer)
m_List = New List(Of T)(list)
m_Length = length
End Sub
Public ReadOnly Property Current() As List(Of T) Implements System.Collections.Generic.IEnumerator(Of List(Of T)).Current
Get
If m_Finished Then
Return Nothing
End If
Dim combination As New List(Of T)
For Each position In m_Positions
combination.Add(m_List(position))
Next
Return combination
End Get
End Property
Private ReadOnly Property Current1() As Object Implements System.Collections.IEnumerator.Current
Get
Return Me.Current
End Get
End Property
Public Function MoveNext() As Boolean Implements System.Collections.IEnumerator.MoveNext
If m_Positions Is Nothing Then
Reset()
Return True
End If
While m_CurrentIndex > -1 AndAlso (Not IsFree(m_Positions(m_CurrentIndex) + 1)) _
''//Decrement index of the position we're moving
m_CurrentIndex -= 1
End While
If m_CurrentIndex = -1 Then
''//We have finished
m_Finished = True
Return False
End If
''//Increment the position of the last index that we can move
m_Positions(m_CurrentIndex) += 1
''//Add next positions just after it
Dim newPosition As Integer = m_Positions(m_CurrentIndex) + 1
For i As Integer = m_CurrentIndex + 1 To m_Positions.Count - 1
m_Positions(i) = newPosition
newPosition += 1
Next
m_CurrentIndex = m_Positions.Count - 1
Return True
End Function
Public Sub Reset() Implements System.Collections.IEnumerator.Reset
m_Finished = False
m_Positions = New List(Of Integer)
For i As Integer = 0 To m_Length - 1
m_Positions.Add(i)
Next
m_CurrentIndex = m_Length - 1
End Sub
Private Function IsFree(ByVal position As Integer) As Boolean
If position < 0 OrElse position >= m_List.Count Then
Return False
End If
Return Not m_Positions.Contains(position)
End Function
''//Add IDisposable support here
End Class
End Class
...你可以使用我的代码是这样的：
Dim list As New List(Of Integer)(...)
Dim iterator As New CombinationEnumerable(Of Integer)(list, 3)
For Each combination In iterator
Console.WriteLine(String.Join(", ", combination.Select(Function(el) el.ToString).ToArray))
Next
我的代码给指定长度的组合（3在我的例子），虽然，我才意识到你希望有任何长度的组合（我认为），但这是一个好的开始。
我可以提供以下解决方案 - 尚不完美，不快，它假定输入是一个集合，因此不包含重复的项目。我稍后会添加一些解释。
using System;
using System.Linq;
using System.Collections.Generic;
class Program
{
static void Main()
{
Int32 n = 5;
Int32 k = 3;
Boolean[] falseTrue = new[] { false, true };
Boolean[] pattern = Enumerable.Range(0, n).Select(i => i < k).ToArray();
Int32[] items = Enumerable.Range(1, n).ToArray();
do
{
Int32[] combination = items.Where((e, i) => pattern[i]).ToArray();
String[] stringItems = combination.Select(e => e.ToString()).ToArray();
Console.WriteLine(String.Join(" ", stringItems));
var right = pattern.SkipWhile(f => !f).SkipWhile(f => f).Skip(1);
var left = pattern.Take(n - right.Count() - 1).Reverse().Skip(1);
pattern = left.Concat(falseTrue).Concat(right).ToArray();
}
while (pattern.Count(f => f) == k);
Console.ReadLine();
}
}
它生成确定如果一个元素属于当前组合开始k倍布尔模式的序列真（1）在最左侧，其余所有假（0）。
n = 5 k = 3
11100
11010
10110
01110
11001
10101
01101
10011
01011
00100
下一个模式产生如下。假设当前模式如下。
00011110000110.....
从左到右扫描并跳过所有零（false）。
000|11110000110....
进一步扫描第一个块（真）。
0001111|0000110....
将除最右边一个以外的所有跳过的部分移回最左边。
1110001|0000110...
最后将最右边的一个位置向右移动一个位置。
1110000|1000110...
我不清楚你想让你的VB代码以什么形式返回它生成的组合，但为了简单起见，我们假设一个列表清单。 VB确实允许递归，而递归解决方案最简单。通过简单地遵守输入列表的排序，可以轻松地获得组合而不是排列。
所以，K个出列表L这是N个项目的组合久是：
在伪代码中（使用例如.size来给出列表的长度，[]作为空列表，.append将列表添加到列表中，.head列出第一项，.tail以获得“所有，但第一个” L的项目）的名单：
function combinations(K, L):
if K > L.size: return []
else if K == L.size:
result = []
result.append L
return result
else:
result = []
for each sublist in combinations(K-1, L.tail):
subresult = []
subresult.append L.head
for each item in sublist:
subresult.append item
result.append subresult
for each sublist in combinations(K, L.tail):
result.append sublist
return result
此伪码，如果你承担更多的灵活列表操作语法更加简洁。例如，在Python（“可执行的伪代码”）用“切片”和“列表理解”的语法：
def combinations(K, L):
if K > len(L): return []
elif K == len(L): return [L]
else: return [L[:1] + s for s in combinations(K-1, L[1:])
] + combinations(K, L[1:])
无论您是需要反复.append以冗长构造列表，或可以通过简洁列表理解符号构建它们，是一个语法细节（正如选择首尾相对列表切片符号以获得列表的第一项与其余部分一样）：伪代码旨在表达完全相同的想法（这也表达了相同的想法英文在前面的编号列表中）。你可以用任何能够递归的语言实现这个想法（当然，还有一些最小的列表操作！）。在C＃
我捻，先提供一个排序列表，按长度 - 然后通过阿尔法
Imports System.Collections.Generic
Public Class LettersList
Public Function GetList(ByVal aString As String) As List(Of String)
Dim returnList As New List(Of String)
' Start the recursive method
GetListofLetters(aString, returnList)
' Sort the list, first by length, second by alpha
returnList.Sort(New ListSorter)
Return returnList
End Function
Private Sub GetListofLetters(ByVal aString As String, ByVal aList As List(Of String))
' Alphabetize the word, to make letter key
Dim tempString As String = Alphabetize(aString)
' If the key isn't blank and the list doesn't already have the key, add it
If Not (String.IsNullOrEmpty(tempString)) AndAlso Not (aList.Contains(tempString)) Then
aList.Add(tempString)
End If
' Tear off a letter then recursify it
For i As Integer = 0 To tempString.Length - 1
GetListofLetters(tempString.Remove(i, 1), aList)
Next
End Sub
Private Function Alphabetize(ByVal aString As String) As String
' Turn into a CharArray and then sort it
Dim aCharArray As Char() = aString.ToCharArray()
Array.Sort(aCharArray)
Return New String(aCharArray)
End Function
End Class
Public Class ListSorter
Implements IComparer(Of String)
Public Function Compare(ByVal x As String, ByVal y As String) As Integer Implements System.Collections.Generic.IComparer(Of String).Compare
If x.Length = y.Length Then
Return String.Compare(x, y)
Else
Return (x.Length - y.Length)
End If
End Function
End Class