我有一個問題類似，但不完全相同，到了一個回答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