C# 序列数组

假设我有一个整数序列，从0（总是从0开始）到3。现在，我有一个整数数组，它将从某个点开始，一个接一个地循环这些序列。例如：

一个由10个元素组成的数组，序列是0到3，从2开始，应该产生2，3，0，1，2，3，0，1，2，3

一个由5个元素组成的数组，序列0到5，从5开始，应该产生5，0，1，2，3

一个由5个元素组成的数组，序列0到10，从3开始，应该产生3，4，5，6，7

我的大脑冻住了！如果您知道数组大小、序列中的最大数量和起始值，那么创建此数组的最佳方法是什么

---

我最好的尝试是：

private static int[] CreateIndexers(int index, int size, int players) 
{
  var indexers = new int[size];
  for (int i = 0; i < size; i++)
  { 
    var division = i / players; 
    var newInt = division + i >= players ? ((division + i) - players) : division + i;
    indexers[i] = newInt; 
  } 

  return indexers; 
} 

私有静态int[]createIndexer（int索引、int大小、int播放器）
{
变量索引器=新整数[大小]；
对于（int i=0；i=玩家？（（分区+i）-玩家）：分区+i；
索引器[i]=newInt；
} 
返回索引器；
} 

以下是一个不太“灵巧”的解决方案：

    public static IEnumerable<int> GetSequence(int start, int end, int count)
    {
        var fullSequence = new List<int>();
        var baseRange = Enumerable.Range(0, end + 1);
        fullSequence.AddRange(baseRange.Skip(start));

        while (fullSequence.Count < count)
        {
            fullSequence.AddRange(baseRange);
        }

        return fullSequence.Take(count);
    }

公共静态IEnumerable GetSequence（int开始、int结束、int计数）
{
var fullSequence=新列表（）；
var baseRange=可枚举范围（0，结束+1）；
fullSequence.AddRange（baseRange.Skip（start））；
while（fullSequence.Count

公共静态IEnumerable Foo（int count、int start、int max）
{
返回可枚举范围（0，计数）
。选择（n=>（n+开始）%（最大值+1））；
}

int numberOfElements=10；
int sequenceStartElement=0；
int sequenceCount=4；
int firstElement=2；
IEnumerable sequence=Enumerable.Range（sequenceStartElement，sequenceCount）
int[]数组=序列
//你可以找出一个较小的数字来重复。。。但这是推迟的，没关系。
.重复（numberOfElements）
.SkipWhile（x=>x！=firstElement）
.Take（numberOfElements）
.ToArray（）；

---

如果您知道数组大小、序列中的最大数量和起始值，那么创建此数组的最佳方法是什么

我看到有三个列出的输入，而不是之前考虑的四个。下面是如何使用您的方法来实现这一点

private static int[] CreateIndexers(int firstElement, int numberOfElements, int sequenceMax) 
{
  int sequenceCount = sequenceMax + 1
  var indexers = new int[numberOfElements];
  for (int i = 0; i < numberOfElements; i++)
  { 
    indexers[i] = (i + firstElement) % sequenceCount;
  } 
  return indexers; 
} 

private static int[]createIndexer（int firstElement、int numberOfElements、int sequenceMax）
{
int sequenceCount=sequenceMax+1
变量索引器=新的整数[numberOfElements]；
for（int i=0；i

使用LINQ：

public static IEnumerable<int> Foo(int length, int start, int end)
{
    return Enumerable.Range(start, length).Select(n => n % (end + 1));
}

公共静态IEnumerable Foo（int-length、int-start、int-end）
{
返回可枚举的范围（开始，长度）。选择（n=>n%（结束+1））；
}

你能发布一些代码吗？解释你被困在哪里。就目前而言，这看起来像是你想让我们为你编写代码。到目前为止你尝试过什么吗？呼应“你尝试过什么？”的路线-这个问题太“为我写”了。你可以写“你可以使用Linq”来获得一个不太灵巧的解决方案，它仍然有很多Linq…（这不是一件坏事，只是说）。真棒，我从没想过会这样！你也可以重复

int.MaxValue

，因为

Take

确保你永远不会到达终点。+1聪明，非常好。我花了半分钟来理解它的工作原理：）+1与我的类似，但你可以从start@vlad是的，我想你可以。不过，这种手术似乎不值得花太多时间。

int numberOfElements = 10;
int sequenceStartElement = 0;
int sequenceCount = 4;
int firstElement = 2;

IEnumerable<int> sequence = Enumerable.Range(sequenceStartElement, sequenceCount)
int[] array = sequence
     //you could figure out a lesser number to Repeat... but it's deferred, doesn't matter.
  .Repeat(numberOfElements) 
  .SkipWhile(x => x != firstElement)
  .Take(numberOfElements)
  .ToArray();

private static int[] CreateIndexers(int firstElement, int numberOfElements, int sequenceMax) 
{
  int sequenceCount = sequenceMax + 1
  var indexers = new int[numberOfElements];
  for (int i = 0; i < numberOfElements; i++)
  { 
    indexers[i] = (i + firstElement) % sequenceCount;
  } 
  return indexers; 
} 

public static IEnumerable<int> Foo(int length, int start, int end)
{
    return Enumerable.Range(start, length).Select(n => n % (end + 1));
}