Generate array with pairs of numbers

我有这样的代码：

Random num = new Random();
            int check = CheckIfOdd(num.Next(1, 1000000));
            int counter = 1;

            while (check <= 0)
            {
                if (check % 2 == 0)
                {
                    check = CheckIfOdd(num.Next(1, 1000000)); ;
                }
                counter++;
            }
            int[] nArray = new int[check];
            int arLength = 0;
            //generate arrays with pairs of numbers, and one number which does not pair.
            for (int i = 0; i < check; i++)
            {
                arLength = nArray.Length;

                if (arLength == i + 1) 
                {
                    nArray[i] = i + 1;
                }
                else
                {
                    nArray[i] = i;
                    nArray[i + 1] = i;
                }
                i++;
            }

这确实有点儿工作，但不是还有我想。

它应该产生与1之间的阵列 - 元素1万元，人数之内可以是1之间 - 十亿1。

它具有使2对每个数字的，在该阵列中的随机位置（它现在不），然后它应包含1号，其具有一对没有...

我只是在寻找做一个更好的方式，因为它不是在随机位置，并且它不正确1- 1十亿之间产生的数字。

编辑我已经提出这样的：（由oerkelens）

var total = new Random().Next(500000) * 2 + 1;
            var nArray = new int[total];
            for (var i = 1; i < total; i += 2)
            {
                nArray[i] = i;
                nArray[i - 1] = i;
            }
            nArray[total - 1] = total;

哪一个更好，而不是尽可能多的代码，但它不会使这些值按随机顺序。

编辑2这几乎做什么，我需要的，但它不会产生各适量。如所述的，它应产生最大为x的元素，以1-Y之间的数

Random r = new Random();
int[] output = Enumerable.Range(0, 11).Select(x => x / 2).OrderBy(x => r.Next()).ToArray();

通过Enigmativity

试试这个代码：

int[] output = Enumerable.Range(0, 11).Select(x => x / 2).ToArray();

它可生成具有这些值的阵列：

{ 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5 }

你应该能够将其扩展到你需要尽可能多的元素。

如果你想在一个随机顺序输出，那么试试这个：

Random r = new Random();
int[] output = Enumerable.Range(0, 11).Select(x => x / 2).OrderBy(x => r.Next()).ToArray();

在一个运行，作为一个例子，我得到这个：

{ 0, 4, 1, 2, 2, 4, 5, 3, 3, 1, 0 }

要产生大量随机对你可以这样做一个单一的元素：

Random r = new Random();
int pairs = 5; //elements = 2 * pairs + 1;
int max = 100;
int[] output =
    Enumerable
        .Range(0, pairs)
        .Select(x => r.Next(1, max + 1))
        .SelectMany(x => new [] { x, x })
        .StartWith(r.Next(1, max + 1))
        .OrderBy(x => r.Next())
        .ToArray();

然而，这并不能保证你不与3的碰撞，4个或更多数量的冲突结束。

这并不需要“System.Interactive”：

int[] output =
    new [] { r.Next(1, max + 1) }
        .Concat(
            Enumerable
                .Range(0, pairs)
                .Select(x => r.Next(1, max + 1))
                .SelectMany(x => new [] { x, x }))
        .OrderBy(x => r.Next())
        .ToArray();