C# 如何用唯一的随机数填充二维数组

如何用唯一的随机数（行/列中的不同数）填充二维数组

我已经为一维数组做过了：

class Program
{
    static void Main(string[] args)
    {
        Random r = new Random();

        int[] x = new int[10];

        for(int i = 0; i < x.Length; i++)
        {
            x[i] = r.Next(9);

            for(int j = 0; j < i; j++)
            {
                if(x[i] == x[j])
                {
                    i--;
                    break;
                }
            }
        }

        for(int i = 0; i < x.Length; i++)
        {
            Console.WriteLine(x[i]);
        }

        Console.ReadKey();
    }
}

类程序
{
静态void Main（字符串[]参数）
{
随机r=新随机（）；
int[]x=新的int[10]；
对于（int i=0；i

由于您不需要任何副本，因此重复使用

随机

，直到每个副本都有一个副本，这不是最好的方法。从理论上讲，如果随机发生器不能在早期提供所需的值，这样的算法可能会运行很长时间

由于您知道需要什么值，但希望它们以随机顺序排列，因此算法通常是更好的方法。 洗牌算法允许您生成所需值的数组，然后洗牌以随机顺序获得它们

让它在多维数组中工作的最简单方法可能是首先将所有所需的值放入一维数组中，将其洗牌，然后将数组转换为多维数组。 但是，要将洗牌算法推广到多维数组上，需要进行以下操作

---

参考答案中提供了代码的示例。

这听起来有点像家庭作业。下面是将一个固定范围（在您的例子中是10x10）的整数混合到一个二维整数数组中的想法，例如

int[10,10]

：

using System;
using System.Linq;
using System.Collections;

class MainClass {

  public static void Main (string[] args) {
    // table dimension (assumes a square)
    var dim = 10;
    var table = new int?[dim, dim];

    // 100 integers: 0..99
    var queue = new Queue(Enumerable.Range(0, dim * dim).ToList<int>());
    var rng = new Random();


    int x = dim / 2, y = dim / 2;

    // Acceptable shuffle? As long as the queue has anything in it, try to place the next number
    while(queue.Count > 0) {
        x = rng.Next(dim);  // still using random, not great! :(
        y = rng.Next(dim);

        if(table[x,y] == null)
            table[x,y] = (int)queue.Dequeue();
    }

    // print output so I know I'm not crazy
    for(var i = 0; i < dim; i++) {
        Console.Write("Row {0}: [", i);
        for(var j = 0; j < dim; j++) {
            Console.Write("{0,4}", table[i,j]);
        }
        Console.WriteLine("]");
    }
  }
}

---

下面是我实现MAV答案的一个尝试：

private Random random = new Random();

private void Shuffle(ref int[] array)
{
    int r, temp;
    for (int i = array.Length - 1; i >= 0; i--)
    {
        r = random.Next(i + 1);
        temp = array[r];
        array[r] = array[i];
        array[i] = temp;
    }
}

public int[,] GetUniqueArray()
{
    int[,] array = new int[10,10];

    int[] temp = Enumerable.Range(0, 100).ToArray();
    Shuffle(ref temp);

    for (int i = 0; i < temp.Length; i++)
    {
        array[i / array.GetLength(0), i % array.GetLength(1)] = temp[i];
    }

    return array;
}

private Random=new Random（）；
私有无效洗牌（ref int[]数组）
{
温度；
对于（int i=array.Length-1；i>=0；i--）
{
r=随机。下一个（i+1）；
温度=阵列[r]；
数组[r]=数组[i]；
数组[i]=温度；
}
}
public int[，]GetUniqueArray（）
{
int[，]数组=新的int[10,10]；
int[]temp=Enumerable.Range（01100）.ToArray（）；
洗牌（参考温度）；
对于（int i=0；i

正如他所说，强制数组的内容是随机的和唯一的可能会导致问题，这取决于数组的大小。如果您遇到了一个生成大量冲突的情况，那么它可能会导致您的程序缓慢爬行，而它会为单个数组索引生成数百个随机数，只是盲目地寻找尚未使用的一个

这种方法更好，因为您从一个已经填充了唯一数字的所需大小的数组开始，然后您只需随机化它们的顺序。您可以通过稳定的运行时间和少得多的问题获得所需的结果

private Random random = new Random();

private void Shuffle(ref int[] array)
{
    int r, temp;
    for (int i = array.Length - 1; i >= 0; i--)
    {
        r = random.Next(i + 1);
        temp = array[r];
        array[r] = array[i];
        array[i] = temp;
    }
}

public int[,] GetUniqueArray()
{
    int[,] array = new int[10,10];

    int[] temp = Enumerable.Range(0, 100).ToArray();
    Shuffle(ref temp);

    for (int i = 0; i < temp.Length; i++)
    {
        array[i / array.GetLength(0), i % array.GetLength(1)] = temp[i];
    }

    return array;
}