按顺序生成数字

Question

给定 startIndex、数字计数和最大数字，我如何使用 LinQ 按此顺序生成数字。例如：

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 来实现？

Answer 1

如果您不需要序列的长度是动态的，那么您可以使用：

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。

如果要动态连接任意数量的枚举，则可以使用 Eric Lippert 的笛卡尔积 Linq 示例。

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

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

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

这是最终的解决方案（为清楚起见进行了编辑）：

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);
}

Answer 2

试试这个功能。

public static IEnumerable<IEnumerable<T>> Permute<T>(IEnumerable<T> list)
        {
            if (list.Count() == 1)
                return new List<IEnumerable<T>> { list };

            return list.Select((a, i1) => Permute(list.Where((b, i2) => i2 != i1)).Select(b => (new List<T> { a }).Union(b)))
                       .SelectMany(c => c);
        }

//这里 Range(startindex, count)

List<int> list1 = Enumerable.Range(1, 3).ToList();

//生成所有排列

var permutationlist = Permute(list1);

---

Answer 3

好吧，首先我们把问题说清楚。我假设你的数字是int，但这基本上是一个无关紧要的细节，但具体性让思考变得更加简单。

你有一个序列a_0, a_1, a_2, ..., a_Nint 的 >。

您有一个满足 1 <= k <= N + 1 的整数 k。

您有一个起始索引 start >=0 和一个结束索引 end <= N。

您希望长度为 k 的所有子序列 a_i0, a_i1, a_i2, ..., a_ik 使得 i0 = start 和 ik =结束。

那么你的算法就很简单了。您想要生成 { start + 1, ..., end - 1 } 的大小 k - 2 的所有组合。给定这样的组合j1, j2, ..., j(k-1)，对其进行排序，调用生成的有序序列i1, i2, ..., i(k-1) ) 并返回序列 a_start, a_i1, a_i2, ..., a_i(k-1), a_end。

现在您已经知道了问题的正式陈述以及解决问题所需的内容，用于生成所述组合的资源有很多。参见Google 搜索：生成组合 C# 或 高德纳第 4A 卷。