从1,50随机20个不重复数
要求:不允许重复.我这么写的.觉得好傻
ArrayList list = new ArrayList();
int k = 0;
do
{
k =random .Next (1,51);
if (!list.Contains(k))
list.Add(k);
}
while (list.Count < 20);
[解决办法]
List <int> numbers=new List <int> ();
List <int> result=new List <int> ();
Random rand=new Random();
for(int i=1;i <51;i++){
numbers.Add(i);
}
while(numbers.Count> 0){
int n=rand.Next(0,numbers.Count);
result.Add(n);
numbers.RemoveAt(n-1);//number.Remove(n);
}
//大概这样吧，没测试~~~
[解决办法]
public static void Main()
{
int []a=new int[50];
Random ra=new Random();
for(int i=0;i <50;i++)
{
int str=ra.Next(0,49);
if(a[str]==0)
{
a[str]=i;
}
else
{
i--;
}
}
for(int j=0;j <50;j++)
{
Console.WriteLine(a[j]);
}
}
楼主可以试下我的方法
[解决办法]
回复人：he_8134(只有星星伴明月)
哈哈，我写错了一点点~~~~
numbers.RemoveAt(n-1);//number.Remove(n);
----------
错的就是这一点点吧...
回复人：changkimkim()
LZ的已经不错了，没觉得还有什么更好的方法
--------------
LZ的方法不算傻...应该说是很常规的...但是更好的方法还是有的...
Random rnd = new Random();
byte[] keys = new byte[50];
rnd.NextBytes(keys);
int[] items = new int[50];
for (int i = 0; i < 50; i++)
{
items[i] = i + 1;
}
Array.Sort(keys, items);
int[] result = new int[20];
Array.Copy(items, result, 20);
return result;
[解决办法]
http://blog.csdn.net/vrhero/archive/2007/07/29/1714682.aspx
总结了一下，写成一个通用方法...放在blog里...
[解决办法]
vrhero：
请教一下啊，
1
rnd.NextBytes(keys);这个是不是用随即数把KEYS数组添满，那他啊里面会有重复的数吗？
2
Array.Sort(keys, items);他是怎么进行排序的，应该是根据KEYS里的元素进行排序吧，那KEYS里的元素要是重复了怎么办，这样能保证items里的前20个元素就是所要的元素吗？？
[解决办法]
good
[解决办法]
to JL99000:
1.Random.NextBytes 方法将字节数组的每个元素均设置为一个 0 - 255 之间的随机数，既然是随机数自然难免重复，数组长度大于256时必然会有重复...
2.首先我们保证 items 的元素没有重复，其次 Array.Sort 方法的 QuickSort 算法执行不稳定排序，即使 keys 中两元素相等，对应 items 中的两元素顺序也不可预知，这不就是我们要的随机吗...
MSDN 对 Array.Sort(Array, Array) 方法的说明...
Array.Sort(Array, Array) 方法基于第一个 Array 中的关键字，使用每个关键字的 IComparable 实现，对两个一维 Array 对象（一个包含关键字，另一个包含对应的项）进行排序。
keys Array 中的每个关键字在 itemsArray 中都有对应项。当关键字在排序过程中重新定位时，itemsArray 中的对应项也同样重新定位。因此，itemsArray 根据 keysArray 中对应关键字的排列进行排序。
keys Array 中的每个关键字均必须实现 IComparable 接口，才能与其他任何关键字进行比较。
如果排序不能成功地完成，则结果未定义。
此方法使用 QuickSort 算法。此实现执行不稳定排序；亦即，如果两元素相等，则其顺序可能不被保留。相反，稳定排序保留相等元素的顺序。
一般情况下，此方法的运算复杂度为 O(n log n)，其中 n 是 keys 的 Length；最坏的情况下其运算复杂度为 O(n ^ 2)。
[解决办法]
学习
