C＃中的随机数生成器 - 唯一值

Question

我忙于编写数组的C＃中。我可以用随机生成填满它，但现在是我的问题我如何做到这一点，但这样我可以检查是否值已经是数组中，如果是产生新的价值

额外的信息：
最大值：100
元素的数量：100

重要PLZ工作的进一步ON MY IDEA

我的想法

public void FillArray(int[] A, int Range) 
{ 
    for (int I = 0; I < A.Length; I++) 
    { 
     A[I] = ValidNumber(T, I, Range); 
    } 
} /* Fill Array */ 

选择执行排序

public void SelectionSort(int[] A) 
{ 
    int K, X; 
    for (int I = 0; I < A.Length - 1; I++) 
    { 
     K = I; 
     X = A[K]; 
     for (int J = I + 1; J < A.Length; J++) 
     { 
      if (A[J] < X) 
      { 
       K = J; 
       X = A[K]; 
      } 
     } 
     A[K] = A[I]; 
     A[I] = X; 
    } 
} /* Selection sort */ 

这些都只是一些想法，现在我想知道我可以修复它，这样我可以看看有选择排序，如果有ALLREAD那里（fillarray）是相同的，如果这样更换具有新的随机值。所以我想用随机顺序创建一个随机数组（从1到100）

Answer 1

以下将以随机顺序生成数字为1-100的数组。

Random rnd = new Random(); 
    var randomNumbers = Enumerable.Range(1, 100).OrderBy(i => rnd.Next()).ToArray(); 

Answer 2

这里有一个天真的实现：

int[] values = new int[100]; 
Random random = new Random(); 
for(int i = 0; i < values.Length; i++) 
{ 
    int v; 
    do 
    { 
     v = random.Next(100) + 1; 
    } while (Array.IndexOf(values, v) != -1) 
    values[i] = v; 
} 

但是这将是非常低效的，尤其是靠近数组的结尾......

一个更好的解决办法是要考虑的是，由于你需要100个不同的值，从1到100以随机顺序排列，你的数组最终将包含从1到100的所有可能的值。所以你只需要生成这些值的序列，并“洗牌”它：

int[] values = Enumerable.Range(1, 100).ToArray(); 
Random random = new Random(); 
for(int i = values.Length - 1; i > 0; i--) 
{ 
    int j = random.Next(i + 1); 
    int tmp = values[i]; 
    values[i] = values[j]; 
    values[j] = tmp; 
} 

---

编辑：更好的方法，应该少特定情况下工作：

T[] RandomCombinationWithNoRepeat<T>(IEnumerable<T> itemsToPickFrom, int numberOfItemsToPick) 
{ 
    // Copy original items to pick from, because we need to modify it 
    List<T> itemsCopy = new List<T>(itemsToPickFrom); 
    T[] array = new T[numberOfItemsToPick]; 
    Random random = new Random(); 
    for(int i = 0; i < numberOfItemsToPick; i++) 
    { 
     // Pick item and remove it from list 
     int index = random.Next(itemsCopy.Count); 
     array[i] = itemsCopy[index]; 
     itemsCopy.RemoveAt(index); 
    } 
    return array; 
} 

在你的情况，你会使用它这样的：

int[] result = RandomCombinationWithNoRepeat(Enumerable.Range(1, 100), 100); 

Answer 3

从你的描述我认为你需要一个100个整数的数组，数值从1到100并且没有重复的数字。如果数字是整数，则不需要生成随机数字，因为所有可能的数字都在数组中。因此，只有订单或数字可以随机化。

使用Linq和Jesper Palm的方法 - 通过Thomas Levesque的以下语句将为您提供所需的数组。

Random rnd = new Random(); 
var randomNumbers = Enumerable.Range(1, 100) 
           .Select(x => new { val = x, order = rnd.Next() }) 
           .OrderBy(i => i.order) 
           .Select(x => x.val) 
           .ToArray(); 

该方法甚至相当快，明显比任何比较操作更高效。

为了解释上述的原来的海报，请参阅评论如下：

• Enumerable.Range(1, 100)创建一个范围从1开始，并在100结束整数。
• .Select(x => new { val = x, order = rnd.Next() })创建一个新的临时对象，其中包含由随机数确定的值和顺序位置。
• .OrderBy(i => i.order)按临时对象的顺序排序临时对象。
• .Select(x => x.val)选择临时对象的值，从而转换回int。
• .ToArray()将整个事情再次变回数组。

使用的语法是在.NET 3.5中可用的LINQ。对于旧版本，你必须自己实现它，这要复杂得多，而且时间更长。

继Eric的评论：如果shuffeling被requried你可以做如下代码

var list = myInputList; 
var result = list.Select(x => new { val = x, order = rnd.Next() }) 
       .OrderBy(i => i.order) 
       .Select(x => x.val) 
       .ToArray(); 

Answer 4

从我所了解

。你需要一个随机数的整数集合。我假设使用int数组或List的int无关紧要。 这是一个简单的完整方法，你已经描述过了。
using System; using System.Collections.Generic; using System.Text;

namespace FillRandom { class Program { static void Main(string[] args) { int minValue = 1; int maxValue = 100; //create a list of int with capacity set as 100 List array = new List(100);

 FillArray(array, minValue, maxValue, array.Capacity); 

     //print out all values in the array 
     foreach (int i in array) 
     { 
      Console.WriteLine(i); 
     } 
    } 

    private static void FillArray(List<int> array, int minValue, int maxValue, int capacity) 
    { 
     int count = 0; 
     while (array.Count != capacity - 1) 
     { 
      Random rnd = new Random(); 
      int value = rnd.Next(minValue, maxValue); 
      if (!array.Contains(value)) 
      { 
       array.Add(value); 
      } 
      count++; 
     } 
     //print out the number of times the looping occurs 
     Console.WriteLine("count: "+count); 
    }   
} 

}

您可以创建一个控制台项目并试一试。

Answer 5

我如何做到这一点，但这样我可以检查是否值已经是数组中，如果是产生新的价值

你不这样做，直到永远，因为那是一个非常糟糕的主意。

为了说明为什么它是一个可怕的想法，可以考虑同样的问题的另一个版本：通过下列方法一百万的数字为随机进行排序：

1. 选择从一个数百万。
2. 检查它是否已经在列表中。
3. 如果是，请返回步骤1
4. 否则，将该号码添加到列表中。
5. 该清单上是否有一百万件物品？如果是，你就完成了。如果不是，请返回步骤1.

很明显，这是有效的。这是个好主意吗？假设你快完成了。该清单上有999999项。唯一缺少的项目是857313.你是做什么的？你选择一个随机数字，比如12。现在你检查列表上的999999项目，看它们中的任何一个是否为12. 12可能是你选择的第一个数字之一，所以它可能会很快找到它。或者它可能是最后一个，所以需要很长时间。平均来说，需要500000个支票来查看列表中是否有12个。而且，因为列表中只有一个数字。

12没有解决。回到起点。选择另一个随机数字，比如说53259.是否在列表中？另有五十万支票。

继续这样做，直到您生成857313，每100万次尝试一次。

因此，平均而言，将最后一个项目放在列表中需要500000 x 1000000 =五千亿比较。它可能会更多。它可能需要几万亿次比较。或者你可能会很幸运，而且需要一个。但平均来说，有50万亿次比较。

这是一个可怕的方式来产生一个列表的随机排序。

有两种好方法可以对列表进行随机排序。

（1）制作一个设备，它可以对给定排序功能的列表进行排序。提供基于随机种子的稳定排序。

请注意，您应该而不是产生一个随机排序通过使一个方法返回随机结果时问“是比A大吗？这是一个不稳定的顺序;许多排序算法都是基于稳定的排序顺序进行预测的，当排序顺序不稳定时会进入无限循环或出现其他不良行为。

这个算法是O（n lg n），并且具有很好的属性，它很容易写出标准部件，就像其他答案指出的那样。对于典型实现中的小列表来说，它的速度也非常快。

（2）随机从源列表中选择一个索引项，从源列表中删除，并将其放在目标列表中。

后者被称为Knuth Shuffle或Fischer-Yates Shuffle，它是一个非常快速的算法。您可以“就地”完成此操作，将现有数组变为洗牌顺序或创建新列表。它还有一个很好的属性，你可以“付费玩”，根据需要对列表中的“顶部”进行洗牌。如果你有一百万件物品需要洗牌，但你只需要第一百件，那么你就可以制定出第一百件物品的分类顺序，并称之为好。