计算给定长度的所有可能的子序列（C＃） [英] Calculating all possible sub-sequences of a given length (C#)

问题描述

如果我有一个序列如下（假设这是一个的IEnumerable＆LT; T＆GT; ）：

  [A，B，C，D，E]
 

那么什么是计算所有可能的（连续和非连续）子序列最彻底的方法给定长度？排序结果在结果集中的并不重要，但它不应该包含重复。

例如。如果我要计算长度为3的所有可能的子序列的结果集将是：

  [A，B，C]
[A，B，D]
[A，B，E]
[A，C，D]
[高手]
[A，D，E]
[B，C，D]
[B，C，E]
[B，D，E]
[C，D，E]
 

---

有关备案，已接受的答案下面给了我一个很好的起点，这里的code我已经与被更新为使用一些新的.NET 3.5的扩展方法：

 公共静态的IEnumerable＆LT; IEnumerable的＆LT; T＆GT;＆GT;个子＆LT; T＆GT;（
    这IEnumerable的＆LT; T＆GT;资源，
    诠释计数）
{
    如果（计数== 0）
    {
        收益回报Enumerable.Empty＆LT; T＆GT;（）;
    }
    其他
    {
        VAR跳跃= 1;
        的foreach（VAR第一源）
        {
            的foreach（VAR休息source.Skip（跳过）.Subsequences（计数 -  1））
            {
                收益回报Enumerable.Repeat（第1）.Concat（休息）;
            }

            跳过++;
        }
    }
}
 

解决方案

我已经受够了IANG的的 PermuteUtils 类：

 的char []项目=新的char [] {'A'，'B'，'C'，'D'，'E'};

的foreach（IEnumerable的＆LT;焦炭＆GT;排列在PermuteUtils.Permute（项目，3））{
    Console.Write（[）;
    的foreach（以字符排列三）{
        Console.Write（+ C）;
    }
    Console.WriteLine（]）;
}
 

结果是：

[A B C]
[A B D]
[A B E]
[A C B]
[A C D]
[ 高手 ]
[A D B]
[A D C]
[A D E]
[A E B]
[A E C]
[A E D]
[B A C]
[ 坏 ]
[B A E]
[B C A]
[B C D]
[B C E]
[B D A]
[B D C]
...

If I have a sequence as follows (let's say it's an IEnumerable<T>):

[A, B, C, D, E]

Then what's the cleanest way to compute all possible (continuous and non-continuous) subsequences of a given length? Ordering of the results in the result set isn't important, but it shouldn't include duplicates.

e.g. If I want to compute all possible subsequences of length 3 the result set would be:

[A, B, C]
[A, B, D]
[A, B, E]
[A, C, D]
[A, C, E]
[A, D, E]
[B, C, D]
[B, C, E]
[B, D, E]
[C, D, E]

---

For the record, the accepted answer below gave me a good starting point, and here's the code I've gone with that is updated to use some of the new .NET 3.5 extension methods:

public static IEnumerable<IEnumerable<T>> Subsequences<T>(
    this IEnumerable<T> source, 
    int count)
{
    if (count == 0)
    {
        yield return Enumerable.Empty<T>();
    }
    else
    {
        var skip = 1;
        foreach (var first in source)
        {
            foreach (var rest in source.Skip(skip).Subsequences(count - 1))
            {
                yield return Enumerable.Repeat(first, 1).Concat(rest);
            }

            skip++;
        }
    }
}

解决方案

I've had success with IanG's PermuteUtils class:

char[] items = new char[] { 'A', 'B', 'C', 'D', 'E' };

foreach (IEnumerable<char> permutation in PermuteUtils.Permute(items, 3)) {
    Console.Write("[");
    foreach (char c in permutation) {
        Console.Write(" " + c);
    }
    Console.WriteLine(" ]");
}

Results in:

[ A B C ]
[ A B D ]
[ A B E ]
[ A C B ]
[ A C D ]
[ A C E ]
[ A D B ]
[ A D C ]
[ A D E ]
[ A E B ]
[ A E C ]
[ A E D ]
[ B A C ]
[ B A D ]
[ B A E ]
[ B C A ]
[ B C D ]
[ B C E ]
[ B D A ]
[ B D C ]
...

这篇关于计算给定长度的所有可能的子序列（C＃）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！