Quelle est la meilleure façon de trouver toutes les combinaisons d'éléments dans un tableau?

Mis à JOUR

Voici un ensemble de fonctions génériques (besoin .net 3.5 ou supérieur) pour les différents scénarios. Les sorties sont pour une liste de {1, 2, 3, 4} et d'une longueur de 2.

Permutations avec répétition

static IEnumerable<IEnumerable<T>> 
    GetPermutationsWithRept<T>(IEnumerable<T> list, int length)
{
    if (length == 1) return list.Select(t => new T[] { t });
    return GetPermutationsWithRept(list, length - 1)
        .SelectMany(t => list, 
            (t1, t2) => t1.Concat(new T[] { t2 }));
}

De sortie:

{1,1} {1,2} {1,3} {1,4} {2,1} {2,2} {2,3} {2,4} {3,1} {3,2} {3,3} {3,4} {4,1} {4,2} {4,3} {4,4}

Permutations

static IEnumerable<IEnumerable<T>>
    GetPermutations<T>(IEnumerable<T> list, int length)
{
    if (length == 1) return list.Select(t => new T[] { t });
    return GetPermutations(list, length - 1)
        .SelectMany(t => list.Where(o => !t.Contains(o)),
            (t1, t2) => t1.Concat(new T[] { t2 }));
}

De sortie:

{1,2} {1,3} {1,4} {2,1} {2,3} {2,4} {3,1} {3,2} {3,4} {4,1} {4,2} {4,3}

K-combinaisons avec répétition

static IEnumerable<IEnumerable<T>> 
    GetKCombsWithRept<T>(IEnumerable<T> list, int length) where T : IComparable
{
    if (length == 1) return list.Select(t => new T[] { t });
    return GetKCombsWithRept(list, length - 1)
        .SelectMany(t => list.Where(o => o.CompareTo(t.Last()) >= 0), 
            (t1, t2) => t1.Concat(new T[] { t2 }));
}

De sortie:

{1,1} {1,2} {1,3} {1,4} {2,2} {2,3} {2,4} {3,3} {3,4} {4,4}

K-combinaisons

static IEnumerable<IEnumerable<T>> 
    GetKCombs<T>(IEnumerable<T> list, int length) where T : IComparable
{
    if (length == 1) return list.Select(t => new T[] { t });
    return GetKCombs(list, length - 1)
        .SelectMany(t => list.Where(o => o.CompareTo(t.Last()) > 0), 
            (t1, t2) => t1.Concat(new T[] { t2 }));
}

De sortie:

{1,2} {1,3} {1,4} {2,3} {2,4} {3,4}

Concernant Pengyang réponse:
Voici ma fonction générique qui peut retourner toutes les combinaisons possibles à partir d'une liste de T:

static IEnumerable<IEnumerable<T>>
GetCombinations<T>(IEnumerable<T> list, int length)
{
if (length == 1) return list.Select(t => new T[] { t });
return GetCombinations(list, length - 1)
.SelectMany(t => list, (t1, t2) => t1.Concat(new T[] { t2 }));
}

Exemple 1:n=3,k=2

IEnumerable<IEnumerable<int>> result =
GetCombinations(Enumerable.Range(1, 3), 2);

De sortie - une liste d'entier-listes:

{1, 1} {1, 2} {1, 3} {2, 1} {2, 2} {2, 3} {3, 1} {3, 2} {3, 3}

.............................................................................

J'ai couru cet exemple et je ne suis pas tout à fait sûr de la justesse des résultats.

Exemple 2:n=3, k=3

IEnumerable<IEnumerable<int>> result =
GetCombinations(Enumerable.Range(1, 3), 3);

De sortie - une liste d'entier-listes:

{1, 1, 1} {1, 1, 2} {1, 1, 3} 
{1, 2, 1} {1, 2, 2} {1, 2, 3} 
{1, 3, 1} {1, 3, 2} {1, 3, 3}
{2, 1, 1} {2, 1, 2} {2, 1, 3} 
{2, 2, 1} {2, 2, 2} {2, 2, 3} 
{2, 3, 1} {2, 3, 2} {2, 3, 3}
{3, 1, 1} {3, 1, 2} {3, 1, 3} 
{3, 2, 1} {3, 2, 2} {3, 2, 3} 
{3, 3, 1} {3, 3, 2} {3, 3, 3}

Cela ne devrait pas arriver avec des combinaisons sinon il devrait préciser que c'est avec la répétition.Voir l'article http://en.wikipedia.org/wiki/Combinations

Il y a des couples de manière très facile de trouver la combinaison de la chaîne entrée par l'utilisateur.

D'abord par l'utilisation de LINQ

private static IEnumerable<string> FindPermutations(string set)
{
var output = new List<string>();
switch (set.Length)
{
case 1:
output.Add(set);
break;
default:
output.AddRange(from c in set let tail = set.Remove(set.IndexOf(c), 1) from tailPerms in FindPermutations(tail) select c + tailPerms);
break;
}
return output;
}

Utiliser cette fonction comme

Console.WriteLine("Enter a sting ");
var input = Console.ReadLine();
foreach (var stringCombination in FindPermutations(input))
{
Console.WriteLine(stringCombination);
}
Console.ReadLine();

Autre moyen est d'utiliser la boucle

//1. remove first char 
//2. find permutations of the rest of chars
//3. Attach the first char to each of those permutations.
//    3.1  for each permutation, move firstChar in all indexes to produce even more permutations.
//4. Return list of possible permutations.
public static string[] FindPermutationsSet(string word)
{
if (word.Length == 2)
{
var c = word.ToCharArray();
var s = new string(new char[] { c[1], c[0] });
return new string[]
{
word,
s
};
}
var result = new List<string>();
var subsetPermutations = (string[])FindPermutationsSet(word.Substring(1));
var firstChar = word[0];
foreach (var temp in subsetPermutations.Select(s => firstChar.ToString() + s).Where(temp => temp != null).Where(temp => temp != null))
{
result.Add(temp);
var chars = temp.ToCharArray();
for (var i = 0; i < temp.Length - 1; i++)
{
var t = chars[i];
chars[i] = chars[i + 1];
chars[i + 1] = t;
var s2 = new string(chars);
result.Add(s2);
}
}
return result.ToArray();
}

vous pouvez utiliser cette fonction comme

Console.WriteLine("Enter a sting ");
var input = Console.ReadLine();
Console.WriteLine("Here is all the possable combination ");
foreach (var stringCombination in FindPermutationsSet(input))
{
Console.WriteLine(stringCombination);
}
Console.ReadLine();

Une autre version de la solution donnée par Vayas. Ci-dessous le code source complet de la classe:

using System.Collections.Generic;
namespace ConsoleApplication1
{
public class Permutation
{
public IEnumerable<T[]> GetPermutations<T>(T[] items)
{
var work = new int[items.Length];
for (var i = 0; i < work.Length; i++)
{
work[i] = i;
}
foreach (var index in GetIntPermutations(work, 0, work.Length))
{
var result = new T[index.Length];
for (var i = 0; i < index.Length; i++) result[i] = items[index[i]];
yield return result;
}
}
public IEnumerable<int[]> GetIntPermutations(int[] index, int offset, int len)
{
switch (len)
{
case 1:
yield return index;
break;
case 2:
yield return index;
Swap(index, offset, offset + 1);
yield return index;
Swap(index, offset, offset + 1);
break;
default:
foreach (var result in GetIntPermutations(index, offset + 1, len - 1))
{
yield return result;
}
for (var i = 1; i < len; i++)
{
Swap(index, offset, offset + i);
foreach (var result in GetIntPermutations(index, offset + 1, len - 1))
{
yield return result;
}
Swap(index, offset, offset + i);
}
break;
}
}
private static void Swap(IList<int> index, int offset1, int offset2)
{
var temp = index[offset1];
index[offset1] = index[offset2];
index[offset2] = temp;
}
}
}

Cela a fonctionné comme il se doit pour les combinaisons.Mais ne permet pas de choisir les combinaisons de n en k ...