3

假设我有一个整数序列，从 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; 
}
4

5 回答 5

9 
public static IEnumerable<int> Foo(int count, int start, int max)
{
    return Enumerable.Range(0, count)
        .Select(n => (n + start) % (max + 1));
}
于 2013-02-21T21:20:43.070 回答
6 
public int[] Cycle(int max, int start, int count)
{
    int cycles = count / max + 1;
    return Enumerable.Repeat(Enumerable.Range(0, max+1), cycles)
        .SelectMany(seq => seq)
        .Skip(start)
        .Take(count)
        .ToArray();
}
于 2013-02-21T21:19:02.970 回答
3

使用 LINQ：

public static IEnumerable<int> Foo(int length, int start, int end)
{
    return Enumerable.Range(start, length).Select(n => n % (end + 1));
}
于 2013-02-21T21:26:56.903 回答
0

这是解决方案的“LINQy”版本较少：

    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);
    }
于 2013-02-21T21:15:54.940 回答
0 
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; 
}
于 2013-02-21T21:22:37.423 回答