随机21个 1-20的数  输出每个数字出现的次数 ，并去除重复的数字 按从大到小顺序排序输出（例： 20 19 18、、、3 2 1）  然后 按顺序将每三个数为一个单位  存放到集合中 （例：{“201918”，“171615”...,"321"}）再将集合中的每一个单位进行反序排列  (例{“181920”，“151617”...,"123"})输出集合中的数据

不要吐槽意义什么的 我只是想尽量多把一些长出现的知识点 加进去  如果能很快顺利的完成  面试题就有很大的把握了  （ 还有一个是字符串分割的知识点 ）
其实面试题 并不难 要相信自己

顶顶LZ，谢谢像LZ一样辛苦出题帮助理解、加深对知识印象的朋友与版主，出题比解题难，顶下。

1.             Random r = new Random();
   
2.             Dictionary<int, int> dict = new Dictionary<int, int>();
   
3. 
   
4.             for (int i = 0; i <= 20; i++)   //将产生的随机数以及随机数出现的次数存放到dict字典中
   
5.             {
   
6.                 int num = r.Next(1, 21);
   
7.                 if (dict.ContainsKey(num))
   
8.                 {
   
9.                     dict[num]++;
   
10.                 }
    
11.                 else
    
12.                 {
    
13.                     dict[num] = 1;
    
14.                 }
    
15.             }
    
16. 
    
17.             int[] arrayKey = new int[dict.Count];   //声明一个存放dict中所有键的数组
    
18.             int[] arrayValue = new int[dict.Count]; //声明一个存放dict中所有值的数组
    
19. 
    
20.             dict.Keys.CopyTo(arrayKey, 0);  //将dict中所有的键拷贝到arrayKey数组中
    
21.             dict.Values.CopyTo(arrayValue, 0);  //将dict中所有的值拷贝到arrayValue数组中
    
22. 
    
23.             Array.Sort(arrayKey, arrayValue);   //将arrayKey和arrayValue两个数组进行升序排列
    
24.             Array.Reverse(arrayValue);
    
25.             Array.Reverse(arrayKey);    //由于要求从大到小，所以需要降序排列
    
26. 
    
27.             foreach (int key in dict.Keys)  //输出除去重复项后的数字以及数字出现的次数
    
28.             {
    
29.                 Console.WriteLine("随机数：{0},出现了：{1}次", key, dict[key]);
    
30.             }
    
31. 
    
32.             for (int i = 0; i < arrayKey.Length; i++)   //将上面的结果降序排列
    
33.             {
    
34.                 Console.WriteLine(arrayKey[i].ToString() + "出现了" + arrayValue[i].ToString()+"次");
    
35.             }
    
36. 
    
37.             List<string> list1 = new List<string>();
    
38.             for (int i = 1; i < arrayKey.Length; i++)   //三个一组，并反序输出
    
39.             {
    
40.                 if (i % 3 == 0)
    
41.                 {
    
42.                     string numStr = arrayKey[i - 1].ToString() + arrayKey[i - 2] + arrayKey[i - 3];
    
43.                     list1.Add(numStr);
    
44.                 }
    
45.             }  
    
46. 
    
47.             foreach (string s in list1) //遍历输出
    
48.             {
    
49.                 Console.Write("三个一组反序输出结果为："+s+"\t");
    
50.             }
    
51. 
    
52.             Console.ReadKey();

复制代码

感觉还是写的麻烦了点

高腾 发表于 2013-6-27 12:14
感觉还是写的麻烦了点

说实话，看不懂，
Dictionary<int, int> dict = new Dictionary<int, int>();


int[] arrayKey = new int[dict.Count];   //声明一个存放dict中所有键的数
int[] arrayValue = new int[dict.Count]; //声明一个存放dict中所有值的数组
连注释都看不懂什么意思，你这些都是从哪学的。

楼主的头像超级恶心，能不能换个别的？？？？？？？？？？？？

直接有hash不是更快吗

1. //建立泛型集合Dictionary<Key,Value>
   
2.             Dictionary<int, int> dt = new Dictionary<int, int>();
   
3.             //创建一个生成整数的随机数生成器
   
4.             Random ran = new Random();
   
5.             List<string> list1 = new List<string>();
   
6.             for (int i = 0; i < 21; i++)
   
7.             {
   
8.                 //随机1-20的数存入num
   
9.                 int num = ran.Next(1, 21);
   
10.                 //使用ContarnsKey()来判断是否存在键
    
11.                 if (!dt.ContainsKey(num))
    
12.                 {   //将每个数字添加至集合中对应的键，初始值为1
    
13.                     dt.Add(num, 1);
    
14.                 }
    
15.                 else
    
16.                 {   ////否则，将对应的值累加
    
17.                     dt[num]++;
    
18.                 }
    
19.             }
    
20.             //用foreach来遍历键值对
    
21.             foreach (KeyValuePair<int, int> kv in dt)
    
22.             {
    
23.                 Console.WriteLine("随机数：{0}出现的次数为{1}次", kv.Key, kv.Value);
    
24.             }
    
25.             //通过linq实现降序排列
    
26.             var result1 = from pair in dt orderby pair.Key descending select pair;
    
27.             foreach (KeyValuePair<int, int> kv in result1)
    
28.             {
    
29.                 Console.WriteLine("{0}出现的次数{1}次", kv.Key, kv.Value);
    
30.             }
    
31.             Console.Read();

复制代码

后面的不知道怎么写了...

您这设计确实让人折腾得够呛的，尝试代码：
        int count = 1; //默认第一个数字不一样
            int[] randomNumber = new int[21]; //记录下标
            int[] position = new int[21];
            Random randomNum = new Random();
            for (int i = 0; i < 21; i++) //得到21个随机数并放到一个数组中
            {
                randomNumber[i] = randomNum.Next(1, 21);
            }
            for (int i = 0; i < 21; i++) //冒泡排序
            {
                for (int j = i; j <21; j++)
                {
                    int temp = 0;
                    if (randomNumber[i] < randomNumber[j])
                    {
                        temp = randomNumber[i];
                        randomNumber[i] = randomNumber[i];
                        randomNumber[j] = temp;
                    }
                }
            }
            Console.WriteLine("21个随机数分别是：");
            for (int i = 0; i < 21; i++)
            {
                Console.Write(randomNumber[i]+" ");
            }
            Console.WriteLine();
            for (int i = 0; i < 20; i++) //记录不一样的数的下标和个数
            {
                if (randomNumber[i] > randomNumber[i + 1])
                {
                    position[i] = 1;
                    count++;
                }
            }
            int[] cutNum = new int[count]; //用来存放删掉重复数的数组
            cutNum[0] = randomNumber[0]; //默认第一个数不一样并赋值
            int tempPosition = 0; //记住不是重复的下标
            for (int j = 1; j < count; j++) //给删掉重复数后的从下标1开始的数组赋值
            {
                for (int i =tempPosition ; i < 21; i++)
                {
                    if (position[i] == 1)
                    {
                        cutNum[j] = randomNumber[i + 1];
                        tempPosition = i + 1;
                        break;
                    }
                }
            }
            string[] strNum = new string[count];// 存放去掉重复数后的数组
            Console.WriteLine();
            Console.WriteLine("去掉重复数后的数组是：");
            for (int i = 0; i < count; i++)//将去掉重复数的数组转成统一战两位的字符串数组
            {
                if (cutNum[i] < 10)
                {
                    strNum[i] = "0" + cutNum[i].ToString();
                }
                else
                {
                    strNum[i] = cutNum[i].ToString();
                }
                Console.Write(cutNum[i]+" ");
            }
            Console.WriteLine();
            Console.WriteLine();
            string[] gather = new string[(count/3+1)];
            for (int i = 0; i < (count/3)*3 ; i+=3) //本循环及下面的两个if语句用来将三个数字放到一个数组中
            {
                gather[i] = strNum[i].ToString() + strNum[i + 1].ToString() + strNum[i + 2].ToString();
            }
            if (count % 3 == 1)
            {
                gather[count / 3] = strNum[count - 1].ToString();
            }
            if (count % 3 == 2)
            {
                gather[count / 3] = strNum[count - 2].ToString() + strNum[count - 1].ToString();
            }
            Console.WriteLine("组合后的字符串为：");
            for (int i = 0; i < (count / 3 + 1); i++)
            {
                Console.Write(gather[i]+" ");
            }
            for (int i = 0; i < (count / 3) * 3; i += 3) //本循环及下面的两个if语句用来将三个数字重新排序
            {
                char[] tempCharArr = new char[6];
                tempCharArr=gather[i].ToArray();
                gather[i] = tempCharArr[4].ToString() + tempCharArr[5].ToString() + tempCharArr[2].ToString()
                    + tempCharArr[3].ToString() + tempCharArr[0].ToString() + tempCharArr[1].ToString();
            }
            if (count % 3 == 2)
            {
                gather[count / 3] = strNum[count - 1].ToString() + strNum[count - 2].ToString();
            }
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("组合内部排升序后的字符串为：");
            for (int i = 0; i < (count / 3 + 1); i++)
            {
                Console.Write(gather[i] + " ");
            }

            Console.ReadKey();