要求 产生54个随机数，随机数范围（1-54），然后将其放到一个新的数组中，数字不能重复，也就是把1-54之间的数打乱，然后放到数组中。
             求解！！！

有木有搞错  随机数范围（1-54） 要求 产生54个随机数且不重复  而随机数的性质是包括下限而不包括上限    大神也难做  
   。。。。。。。。。

• using System.Collections;
  
  
  namespace 不重复随机数
  {
           class Program
          {
                 static void Main(string[] args)
                 {
                      Hashtable hashtable = new Hashtable();//使用默认的初始化容器来初始化Hashtable类的新的空实例
                      Random rdm = new Random();//初始化Random类的新实例
                      int count = 0;//记录输出的个数
                      for (int i = 0; hashtable.Count < 54; i++)//遍历hashtable中的Key
                     {
                              int nValue = rdm.Next(1, 54);//定义变量nValue用于存储产生的随机数
                              if (!hashtable.ContainsValue(nValue))//判断相应键/值是否存在
                              {
                                        hashtable.Add(nValue, nValue);
                                        count++;//记录个数数目 纯粹个人调试用 没任何意义
                                        Console.Write(nValue.ToString() + ",第{0}个\n", count);
  
                                }
  
                     }
                     Console.ReadKey();
               }
         }
  }
  

初次使用Hashtable 有不对的地方 请多多指教！

1. int[] num=new int[54];//声明一个int数组容量54
   
2.             int index = 0;//随即数
   
3.             int tep = 0;
   
4.             //先给数组赋值，1-54
   
5.             for(int i =0;i<54;i++)
   
6.             {
   
7.                 num[i]=i+1;
   
8.             }
   
9.             Random r = new Random();
   
10.             //打乱排序并交换位置
    
11.             for (int i = 0; i < num.Length; i++)
    
12.             {
    
13.                 index= r.Next(i, 54 - 1);
    
14.                 tep = num[i];
    
15.                 num[i] = num[index];
    
16.                 num[index] = tep;
    
17.             }
    
18.             foreach (int i in num)
    
19.             {
    
20.                 Console.WriteLine(i);
    
21.             }
    
22.             Console.ReadKey();

复制代码

这是我的思路，希望对你有帮助。

说下我的想法，主要问题就是要求不重复。大体思路就是这样，先制造一个长度为54的数组a，从a[0]-a[53]分别对应1-54，在定义一个长度为54的数组b存储结果。
1、生成一个0-53的随机数i，然后让b[0]=a[i]
2、删除a数组中下标为i的这个元素，让a数组等于这个新的数组。不知道有没有这样的函数，没有的话自己写一个，比较简单，思路就是新数组中，下标小于i的不变，下标大于等于i的去对应旧数组中的下一个元素。
3、生成一个0-52的随机数i，然后让b[1]=a[i]
4、删除a数组中下标为i的这个元素，让a数组等于这个新的数组。
5、生成一个0-51的随机数i，然后让b[2]=a[i]
6、删除a数组中下标为i的这个元素，让a数组等于这个新的数组。
.
.
.
.//就是2个步骤一个for循环
循环进行53次就行（这一次是生成一个0-1的随机数，然后把a数组中对应的数（此时a数组就2个数了）放入b[52]）。
最后一步就是将a[0]（a数组中最后剩下的那个数）赋给b[53]

思路就是这样，代码我得好好想想，貌似还没弄过这样的题

其实有点小bug
应该是r.next(i,54)的

数组  哈希表   集合 都能解决！  ArrayList  list=new ArrayList();   list 中有一个方法用于判断集合中是否已存在即将添加的值

  static void Main(string[] args)
        {
            int i = 0;
            int[] num = new int[54]; //定义数组存放产生的随机数
            while (i < 54)
            {
                Random ran = new Random();
                int n = ran.Next(1, 55);  //从1-54之间产生一个随机数
                int j;
                for ( j = 0; j < i; j++)
                {
                    if (n == num[j])      //如果产生的随机数在数组中存在则要break 重新产生
                        break;
                }
                if (j == i)
                {
                    num[i] = n;           //把元素添加到数组中
                    i++;
                }
            }

            foreach (int item in num)
            {
                Console.WriteLine(item);  // 打印数组中的元素
            }

            Console.ReadKey();
        }

七里香 发表于 2013-9-13 19:23
这是我的思路，希望对你有帮助。

挺独特的想法，思路上并不是关心每个生成的随机数是多少，而是通过获得的随机数来决定排序，不过你这里用index= r.Next(i, 54);意味着一个数字只能和下标大于等于它的数交换位置，是不是有失公平性啊，
这里我自行定义两个说法，主动换位和被动换位。
主动换位：num对应的数字进行的换位，只有当index=i的时候才不会进行换位，也就是说主动换位时，发生换位的几率是53/54，
被动换位：num[index]对应的数字进行的换位，它换位是由这次随机数字决定的，这个几率是1/54。

主动换位后依然有机会继续换位（包括主动和被动）
被动换位后就没机会换位了，因为你换到前面了，i已经不会再遍历到你了。

比如：54这个数字最多只有一次被动换位的机会（换位次数可能0或1），
53这个数字，有一次主动换位的机会，此次主动换位只能和最后一个数字换（可能已经不是54了，不过这不重要），所以换了之后程序就结束了。或者主动换位之前被动换位了。所以53这个数字换位次数（有且有0或1次）。
52这个数字可能换位次数为0次（轮到他主动换位的时候脸黑，没换上，之后又没有被被动换位），1次（主动和最后一个数字换位，或者被动换位一次）或者2次（主动和倒数第二个数字换位，再主动和最后一个数字换位。或者主动和最后一个数字换位，再被动换位一次）
51可能换位次数0、1、2或3次
。
。
。
。
。
。
1可能换位次数0、1、2、3、4..........或53次。
这里index= r.Next(i, 54);是不是改成index= r.Next(0, 54);比较好呢，这样增加了可进行被动换位的次数，而且虽然对于主动换位的次数，1仍然是最多的53次，54仍然是0次。但是对于任何一个数字，可能进行的最多换位次数（主动+被动）是相等的，都是54次。
但是主动和被动换位还是对概率（也就是随机性）有影响的，毕竟所谓主动换位就是必然进行的换位，而被动换位是看运气的换位。拿1和54这两个数字来说，只有当第一次index=0的时候，1才没有进行这次主动换位（这个几率是1/54），其余时刻1都会更换位置的，而且1更换的位置只要不是最后一个，1依然有主动换位的机会。对于54这个数字，每次只能等待着被动换位，所以即使这种情况下，1这个数字换位次数的数学期望远远也要高于54这个数字换位的数学期望。
感觉随机性不是很强的说。

大虾挂了 发表于 2013-9-13 20:46
挺独特的想法，思路上并不是关心每个生成的随机数是多少，而是通过获得的随机数来决定排序，不过你这里用 ...

上面最后一段打错了，主动换位是53/54几率进行的换位

§風過無痕§ 发表于 2013-9-13 18:01
有木有搞错  随机数范围（1-54） 要求 产生54个随机数且不重复  而随机数的性质是包括下限而不包括上限     ...

小小的说下我的想法，感觉这样运行效率比较低，毕竟人家只要54个随机数，而你这里除非神RP，否则进行的循环次数要比54大很多的。
期望上你这里的循环次数应该=54*（1/54+1/53+1/52+1/51+1/50+。。。。。。+1/1）,这是调和级数，项数很小的时候只能一项一项加，我就加了后10项，大概162，算上前面的40项肯定还会大不少。
应该找个优化的方法。

大虾挂了 发表于 2013-9-13 21:05
小小的说下我的想法，感觉这样运行效率比较低，毕竟人家只要54个随机数，而你这里除非神RP，否则进行的循 ...

嗯，不错只要加一个判定就ok了。
亲你是学数学专业的吗？这么厉害。

以下基于我4楼写的方法的代码，由于数组没有删除某个元素的函数，自己可以去编写，但是无法改变数组长度（虽然这个对这道题没影响）。我采用了自己不太了解的集合，.remove（），可以删除集合中的元素，不过是对其中元素的操作，不是对下标的操作，所以括号中写的是start[index]。

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. 
   
6. namespace 生成54个随机数_要求从1_54不重复
   
7. {
   
8.     class Program
   
9.     {
   
10.         static void Main(string[] args)
    
11.         {
    
12.             int index;
    
13.             List<int> start = new List<int>(); //存储初始数据
    
14.             List<int> result = new List<int>(); //存储结果数据
    
15. 
    
16.             for (int i = 0; i < 54; i++)
    
17.                 start.Add(i + 1);
    
18. 
    
19. 
    
20.             Random r = new Random();  //定义一个随机数
    
21. 
    
22.             //54次循环，每次循环确定一个数
    
23.             for (int i = 0; i < 54; i++)
    
24.             {
    
25.                 index = r.Next(0, 54 - i); //每次循环，随到的数字都会被从start集合中删除，所以每次循环集合长度少1，下标取值范围-1
    
26.                 result.Add(start[index]); //将随到的数字放入result集合中
    
27.                 start.Remove(start[index]); //防止数据重复，删除被随机到的数据
    
28.             }
    
29.             foreach (int i in result)
    
30.                 Console.Write("{0}\t", i);
    
31.                 Console.ReadKey();
    
32. 
    
33.         }
    
34.     }
    
35. }
    

复制代码

七里香 发表于 2013-9-13 21:16
嗯，不错只要加一个判定就ok了。
亲你是学数学专业的吗？这么厉害。

不是数学专业的，只不过数学学的一直还不错，吹吹自己风光的历史吧，高考数学我是满分滴，但是大学就坑爹了，根本没学，高数好像差点挂科，不过后来重新认真学过一段时间高数。

1. using System;
   
2. using System.Collections.Generic;
   
3. using System.Linq;
   
4. using System.Text;
   
5. using System.Collections;
   
6. 
   
7. namespace ConsoleApplication5
   
8. {
   
9.     class Program
   
10.     {
    
11.         static void Main(string[] args)
    
12.         {
    
13. 
    
14.             Rand();
    
15.             Console.ReadKey();
    
16.         }
    
17. 
    
18.         public static void Rand()
    
19.         {
    
20.             ArrayList arand = new ArrayList();//用来存储随机数
    
21.             Random rand = new Random();
    
22.             for (int i = 0; i < 54; i++)
    
23.             {
    
24.                 int rd = rand.Next(1, 55);//产生一个1-54随机数给rd，Next()里面的最大值是不会产生的，跟数组下标一样
    
25.                 if (arand.Contains(rd))
    
26.                 {
    
27.                     i--; //如果数组中存储这个随机数，重新生成一个随机,i来控制随机数个数
    
28.                     continue;
    
29.                 }
    
30.                 else
    
31.                 {
    
32.                     arand.Add(rd);
    
33.                 }
    
34.               
    
35.             }
    
36.             foreach(int d in arand)
    
37.                 Console.Write("{0}\t",d);
    
38.         }
    
39.     }
    
40. 
    
41. }
    

复制代码

     //思路很简单啊，循环让计算机做
            Random random = new Random();
            int[] number = new int[54];
            int count = 1;
            bool flag;
            number[0] = random.Next(1, 54);//赋值数组第一个数
            
          //得到一个随机数如果和之前的不同就赋给第2个数，直到赋满54个数
            while (count < 54)
            {
                flag = true;
                int temp = random.Next(1, 54);
                for (int j = 0; j < count; j++)
                {
                    if (number[j] == temp)
                    {
                        flag = false;
                        break;
                    }
                }
                if (flag == true)
                {
                    number[count] = temp;
                    count++;
                }
            }

产生一个数组1-54 然后random它的下标 放进新数组  快给技术分！

王赟 发表于 2013-9-14 13:42
产生一个数组1-54 然后random它的下标 放进新数组  快给技术分！

??

我的想法是，循环体（不断产生随机数，并且赋值给一个变量，  判断if（如果这个变量的数字等于产生的随机数，那么则重新产生），然后把产生的数字赋给数组）。最后打印输出，不过这个方法的缺点是效率很低。
贴出我的代码

1. int[] resultNum = new int[54]; //用于存储随机数的数组
   
2. int temp = 0;
   
3. Random random = new Random();
   
4. bool repeat = false;
   
5. for (int i = 0; i < 54; i++)
   
6. {
   
7. repeat = true;
   
8. while (repeat)
   
9. {
   
10. repeat = false;
    
11. temp = random.Next(1, 55); //产生1-54的随机数，并赋值给temp
    
12. for (int j = 0; j < i; j++)
    
13. {
    
14. if (temp == resultNum[j]) //如果产生的随机数与数组中的某个数相同，则break，重新产生
    
15. {
    
16. repeat = true;
    
17. break;
    
18. }
    
19. }
    
20. }
    
21. resultNum[i] = temp; //把随机数赋值给数组resultNum
    
22. }
    
23. for (int i = 0; i < 54; i++)
    
24. Console.Write("{0}\t",resultNum[i]); //打印输出这些数
    
25. Console.ReadKey();
    
26. }
    

复制代码