按顺序生成数字 [英] Generating Numbers in sequence

问题描述

在给定startIndex，数字数量和最大数量的情况下，如何使用LinQ按此顺序生成数字.例如:

How can i generate numbers using LinQ in this sequence given the startIndex,count of numbers and the maximum number.For example:

Sample Numbers = 1,2,3,4

StartIndex = 1 (i.e it should start from 1)
Sequence number count = 3 
Maximum number = 4 (i.e till 4)

Expected result given the above details :
 1,2,3
 1,3,4
 1,2,4

是否可以使用linQ做到这一点?

Is there a way to do it using linQ?

推荐答案

如果您不需要序列的长度是动态的，则可以使用:

If you didn't need the length of you sequences to be dynamic, then you could use:

var startindex=1;
var maxindex=4;

var data = Enumerable.Range(startindex,maxindex);
var qry = from x in data
          where x == startindex
          from y in data
          where x < y
          from z in data
          where y < z
          select new { x, y, z };
foreach (var tuple in qry) {
    Console.WriteLine("{0} {1} {2}", tuple.x, tuple.y, tuple.z);
}

序列长度被硬编码为3，因为有3个可枚举要连接:x，y，z.

The sequence length is hardcoded to 3, because there are 3 enumerables being joined: x, y, z.

如果要动态加入任意数量的枚举，则可以使用

If you want to dynamically join an arbitrary number of enumerables, then you can use Eric Lippert's Cartesian Product Linq example.

您传递了一组N个项目的k个序列，它将返回一组长度为k的所有组合.

You pass a set of k sequences of N items, and it will return a set of all combinations of length k.

现在，您不希望结果中出现重复的元素. 因此，我在Eric的示例中添加了以下内容:

Now, you don't want repeated elements in your results. So, I added the following to Eric's example:

where accseq.All(accitem => accitem < item)

这是最终解决方案(为清晰起见进行了编辑):

Here's the final solution (edited for clarity):

var startindex=1;
var maxindex=7;
var count = 3;

// Make a set of count-1 sequences, whose values range from startindex+1 to maxindex
List<List<int>> sequences = new List<List<int>>();

// We only want permutations starting with startindex.  So, the first input sequence to be joined should only have the value startindex.
List<int> list1 = new List<int>();
list1.Add(startindex);
sequences.Add(list1);

// The rest of the input sequences to be joined should contain the range startindex+1 .. maxindex
for (int i=1; i< count; i++)
{
 sequences.Add(Enumerable.Range(startindex+1,maxindex-startindex).ToList());
}

// Generate the permutations of the input sequences
IEnumerable<IEnumerable<int>> emptyProduct = new[] { Enumerable.Empty<int>() };
var result = sequences.Aggregate( 
    emptyProduct, 
    (accumulator, sequence) =>  
      from accseq in accumulator  
      from item in sequence
      where accseq.All(accitem => accitem < item)
      select accseq.Concat(new[] {item}));                

// Show the result
foreach (var x in result)
{
    Console.WriteLine(x);
}

这篇关于按顺序生成数字的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！