Quel est le meilleur moyen de trouver toutes les combinaisons d'éléments dans un tableau?
Quel est le meilleur moyen de trouver toutes les combinaisons d'éléments dans un tableau en c #?
C'est sur!)
static List<List<int>> comb;
static bool[] used;
static void GetCombinationSample()
{
int[] arr = { 10, 50, 3, 1, 2 };
used = new bool[arr.Length];
used.Fill(false);
comb = new List<List<int>>();
List<int> c = new List<int>();
GetComb(arr, 0, c);
foreach (var item in comb)
{
foreach (var x in item)
{
Console.Write(x + ",");
}
Console.WriteLine("");
}
}
static void GetComb(int[] arr, int colindex, List<int> c)
{
if (colindex >= arr.Length)
{
comb.Add(new List<int>(c));
return;
}
for (int i = 0; i < arr.Length; i++)
{
if (!used[i])
{
used[i] = true;
c.Add(arr[i]);
GetComb(arr, colindex + 1, c);
c.RemoveAt(c.Count - 1);
used[i] = false;
}
}
}
MIS &AGRAVE; JOUR
Voici un ensemble de fonctions génériques (nécessite .net 3.5 ou supérieur) pour différents scénarios. Les sorties sont pour une liste de {1, 2, 3, 4} et 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 }));
}
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 }));
}
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 }));
}
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 }));
}
Sortie:
{1,2} {1,3} {1,4} {2,3} {2,4} {3,4}
Cela s'appelle des permutations.
Cela peut vous donner les permutations de n'importe quelle collection:
public class Permutation {
public static IEnumerable<T[]> GetPermutations<T>(T[] items) {
int[] work = new int[items.Length];
for (int i = 0; i < work.Length; i++) {
work[i] = i;
}
foreach (int[] index in GetIntPermutations(work, 0, work.Length)) {
T[] result = new T[index.Length];
for (int i = 0; i < index.Length; i++) result[i] = items[index[i]];
yield return result;
}
}
public static IEnumerable<int[]> GetIntPermutations(int[] index, int offset, int len) {
if (len == 1) {
yield return index;
} else if (len == 2) {
yield return index;
Swap(index, offset, offset + 1);
yield return index;
Swap(index, offset, offset + 1);
} else {
foreach (int[] result in GetIntPermutations(index, offset + 1, len - 1)) {
yield return result;
}
for (int i = 1; i < len; i++) {
Swap(index, offset, offset + i);
foreach (int[] result in GetIntPermutations(index, offset + 1, len - 1)) {
yield return result;
}
Swap(index, offset, offset + i);
}
}
}
private static void Swap(int[] index, int offset1, int offset2) {
int temp = index[offset1];
index[offset1] = index[offset2];
index[offset2] = temp;
}
}
Exemple:
string[] items = { "one", "two", "three" };
foreach (string[] permutation in Permutation.GetPermutations<string>(items)) {
Console.WriteLine(String.Join(", ", permutation));
}
Concernant la réponse de Pengyang: Voici ma fonction générique qui peut renvoyer toutes les combinaisons à 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);
Sortie - une liste de listes entières:
{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);
Sortie - une liste de listes entières:
{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 spécifier que c'est avec répétition.Voir article http://en.wikipedia.org/wiki/Combinations
Peut-être que kwcombinatorics peut-il vous aider (voir l'exemple sur la page d'accueil):
La bibliothèque KwCombinatorics est constituée de 3 classes qui fournissent 3 manières différentes de générer des listes ordonnées (classées) de combinaisons de nombres. Ces combinatoires sont utiles pour les tests de logiciels, permettant de générer différents types de combinaisons possibles d’entrées. D'autres utilisations incluent la résolution de problèmes mathématiques et les jeux de hasard.
Il existe plusieurs méthodes très simples pour trouver la combinaison de saisie de chaîne par utilisateur.
Première façon en utilisant 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;
}
Utilisez cette fonction comme
Console.WriteLine("Enter a sting ");
var input = Console.ReadLine();
foreach (var stringCombination in FindPermutations(input))
{
Console.WriteLine(stringCombination);
}
Console.ReadLine();
Une autre façon 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();
Pour une réponse détaillée, voir: Donald Knuth, L'art de la programmation informatique (alias TAOCP). Volume 4A, Énumération et retour en arrière, chapitre 7.2. Générer toutes les possibilités. http://www-cs-faculty.stanford.edu/~uno/taocp.html
Une autre version de la solution proposée par Gufa. 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 effectivement fonctionné comme il se doit pour les combinaisons.Mais cela ne permet pas de choisir des combinaisons de n en k ...
J'ai créé une méthode pour obtenir la combinaison unique de tous les éléments entiers d'un tableau, comme indiqué ci-dessous. J'ai utilisé Tuple pour représenter une paire ou une combinaison de nombres:
private static void CombinationsOfItemsInAnArray()
{
int[] arr = { 10, 50, 3, 1, 2 }; //unique elements
var numberSet = new HashSet<int>();
var combinationList = new List<Tuple<int, int>>();
foreach (var number in arr)
{
if (!numberSet.Contains(number))
{
//create all Tuple combinations for the current number against all the existing number in the number set
foreach (var item in numberSet)
combinationList.Add(new Tuple<int, int>(number, item));
numberSet.Add(number);
}
}
foreach (var item in combinationList)
{
Console.WriteLine("{{{0}}} - {{{1}}}",item.Item1,item.Item2);
}
}
Lorsque j'appelle cette méthode dans une application console, le résultat est inférieur à la sortie:
{50} - {10}
{3} - {10}
{3} - {50}
{1} - {10}
{1} - {50}
{1} - {3}
{2} - {10}
{2} - {50}
{2} - {3}
{2} - {1}