Combinaison Générateur de Linq

Est-il possible de créer un peu de Linq qui génère une Liste contenant toutes les combinaisons possibles d'une série de chiffres??

Si vous entrez "21", il serait de générer une liste avec les éléments:

list[0] = "21"
list[1] = "22"
list[2] = "11"
list[3] = "12"

(Pas nessesarily dans cet ordre)

- Je comprendre que vous pouvez utiliser la plage à faire des choses comme:

List<char> letterRange = Enumerable.Range('a', 'z' - 'a' + 1).Select(i => (Char)i).ToList(); //97 - 122 + 1 = 26 letters/iterations

Qui génère de l'alphabet de a-z. Mais je n'arrive pas à transférer ce savoir pour faire une combinaison générateur

J'ai été en mesure de le comprendre avec le code suivant, mais il semble trop encombrant et je suis sûr qu'il peut être fait avec quelques lignes. On ressent vraiment une mauvaise solution que j'ai fait.

Imaginer que j'ai appelé GetAllCombinations("4321") si elle contribue à

public static String[] GetAllCombinations(String s)
{
    var combinations = new string[PossibleCombinations(s.Length)];

    int n = PossibleCombinations(s.Length - 1);

    for (int i = 0; i < s.Length; i++)
    {
        String sub;
        String[] subs;

        if (i == 0)
        {
            sub = s.Substring(1); //Get the first number
        }
        else if (i == s.Length - 1)
        {
            sub = s.Substring(0, s.Length - 1);
        }
        else
        {
            sub = s.Substring(0, i) + s.Substring(i + 1); 
        }

        subs = GetAllCombinations(sub);

        for (int j = 0; j < subs.Length; j++)
        {
            combinations[i * n + j] = s[i] + subs[j];
        }
    }

    return combinations;
}
public static int PossibleCombinations(int n) //Combination possibilities. e.g 1-2-3-4 have 24 different combinations
{
    int result = 1;

    for (int i = 1; i <= n; i++)
        result *= i;

    return result;
}

InformationsquelleAutor CasperT | 2009-04-21

c#combinations linq

39

Pour ce que ça vaut, essayez quelque chose comme ceci:
```
public static IEnumerable<string> GetPermutations(string s)
{
    if (s.Length > 1)
        return from ch in s
               from permutation in GetPermutations(s.Remove(s.IndexOf(ch), 1))
               select string.Format("{0}{1}", ch, permutation);

    else
        return new string[] { s };
}
```
- +1 je ne pense pas que cette réponse a assez de upvotes
- Juste pour remarque, cette fonction comme donnée de ne pas faire ce que la question se pose. (Il génère { "12", "21" }, manquant "11" et "22".) Je ne peux que supposer que le demandeur a réussi à l'adapter à quelque chose d'utile.
- Ce code ne fonctionne pas si il y a des doublons de caractères dans la chaîne. Si la chaîne contient "banane", le deuxième appel à IndexOf('a') dans la boucle for sera de retour le premier " a " de nouveau.
InformationsquelleAutor Josh G

Pour l'enregistrement: Josh répondre à la façon générique:

public static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> items) {
        if (items.Count() > 1) {
            return items.SelectMany(item => GetPermutations(items.Where(i => !i.Equals(item))),
                                   (item, permutation) => new[] { item }.Concat(permutation));
        } else {
            return new[] {items};
        }
    }

Ce besoin de plus upvotes. Je préfère toujours générique réponses!
Un mot de prudence: Cela ne fonctionnera pas si deux ou plusieurs éléments dans items sont égaux.

InformationsquelleAutor Marc Wittke

Voici mon Permutation et Combinaison de la fonction à l'aide de Linq

public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource item)
{
if (source == null)
throw new ArgumentNullException("source");
yield return item;
foreach (var element in source)
yield return element;
}
public static IEnumerable<IEnumerable<TSource>> Permutate<TSource>(this IEnumerable<TSource> source)
{
if (source == null)
throw new ArgumentNullException("source");
var list = source.ToList();
if (list.Count > 1)
return from s in list
from p in Permutate(list.Take(list.IndexOf(s)).Concat(list.Skip(list.IndexOf(s) + 1)))
select p.Prepend(s);
return new[] { list };
}
public static IEnumerable<IEnumerable<TSource>> Combinate<TSource>(this IEnumerable<TSource> source, int k)
{
if (source == null)
throw new ArgumentNullException("source");
var list = source.ToList();
if (k > list.Count)
throw new ArgumentOutOfRangeException("k");
if (k == 0)
yield return Enumerable.Empty<TSource>();
foreach (var l in list)
foreach (var c in Combinate(list.Skip(list.Count - k - 2), k - 1))
yield return c.Prepend(l);
}

De l'ADN de l'alphabet 'A', 'C', 'G', 'T':

var dna = new[] {'A', 'C', 'G', 'T'};
foreach (var p in dna.Permutate())
Console.WriteLine(String.Concat(p));

donne

ACGT ACTG AGCT AGTC ATCG ATGC CAGT CATG CGAT CGTA CTAG CTGA GACT GATC GCAT GCTA GTAC GTCA TACG TAGC TCAG TCGA TGAC TGCA

et les combinaisons (k = 2) de l'ADN de l'alphabet

foreach (var c in dna.Combinate(2))
Console.WriteLine(String.Concat(c));

sont

AA AC AG AT CA CC CG CT GA GC GG GT TA TC TG TT

Belle, nécessaires le nombre de combinaisons partie 😀
votre combinaison n'est pas de travail correctes, comme il produire identiques combinaison de fixe - les dans votre exemple, vous pouvez voir " AC " et "CA", ou un autre exemple, " AG " et " GA " - ce que vous produire dans combinate est en fait quelque chose d'autre qui est appelé variations. combinate devrait traiter de " AC " et " CA " comme même chose et donc seul le retour un de ceux. Sauf que j'ai vraiment apprécié l'étude de votre code 🙂
Votre "Combiner la méthode effectue une opération qui s'appelle "partielle permutation'

InformationsquelleAutor Yongkee Cho

1

Ce que vous cherchez sont en fait des permutations. En bref, les permutations signifie que la commande est pertinent (par exemple, 12 est différent de 21), tandis qu'une combinaison de moyens de commande n'est pas pertinent (12 et 21 sont équivalentes). Pour plus d'informations, voir Wikipedia.

Voir ce fil.

Comme pour le faire est dans le plus pur LINQ, qui sonne comme l'utilisation de LINQ pour le bien de l'utilisation de LINQ.
- Eh bien je l'ai mentionné LINQ parce qu'ils sont généralement de 1 ou 2 lignes -> je veux archive que je déteste me fait énormément méthode
- Je vais regarder dans les liens tout de suite 🙂
InformationsquelleAutor Adam Robinson
0

Comme d'autres l'ont souligné les solutions sur cette page vous permettra de générer des doublons si tout les éléments sont les mêmes. Le Distinct() extension de supprimer, mais il n'est pas très évolutif car il sera généralement l'ensemble de l'arbre de recherche traversée de toute façon. Vous allez découper l'espace de recherche considérablement en l'appelant au cours de la traversée:
```
private static IEnumerable<string> Permute(string str)
{
if (str.Length == 0)
yield return "";
else foreach (var index in str.Distinct().Select(c => str.IndexOf(c)))
foreach (var p in Permute(str.Remove(index, 1)))
yield return str[index] + p;
}
```
Pour l'exemple de la chaîne "bananabana" il en résulte 8,294 nœuds visités, par opposition à la 9,864,101 visité quand vous ne faites pas la traversée de l'abattage.

InformationsquelleAutor Mark Feldman

Vous pouvez utiliser cette Permuter extension LINQ:

foreach (var value in Enumerable.Range(1,3).Permute())
Console.WriteLine(String.Join(",", value));

Qui résultats dans ce:

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
...

Vous pouvez éventuellement spécifier le nombre de permutations

foreach (var value in Enumerable.Range(1,2).Permute(4))
Console.WriteLine(String.Join(",", value));

Résultats:

1,1,1,1
1,1,1,2
1,1,2,1
1,1,2,2
1,2,1,1
1,2,1,2
1,2,2,1
1,2,2,2
2,1,1,1
2,1,1,2
2,1,2,1
2,1,2,2
2,2,1,1
2,2,1,2
2,2,2,1
2,2,2,2

Classe d'Extension pour ajouter:

public static class IEnumberableExtensions
{
public static IEnumerable<IEnumerable<T>> Permute<T>(this IEnumerable<T> values) => values.SelectMany(x => Permute(new[] { new[] { x } }, values, values.Count() - 1));
public static IEnumerable<IEnumerable<T>> Permute<T>(this IEnumerable<T> values, int permutations) => values.SelectMany(x => Permute(new[] { new[] { x } }, values, permutations - 1));
private static IEnumerable<IEnumerable<T>> Permute<T>(IEnumerable<IEnumerable<T>> current, IEnumerable<T> values, int count) => (count == 1) ? Permute(current, values) : Permute(Permute(current, values), values, --count);
private static IEnumerable<IEnumerable<T>> Permute<T>(IEnumerable<IEnumerable<T>> current, IEnumerable<T> values) => current.SelectMany(x => values.Select(y => x.Concat(new[] { y })));
}

InformationsquelleAutor Robear

Vous devez vous connecter pour publier un commentaire.