一个超难的考号编排算法问题

样本数据：

年级	学校代码	班级	姓名	考号
1	10	1	吴泽华	1100001
1	10	2	周慧林	1100002
1	10	3	王彬吉	1100003
1	10	4	张梓萍	1100004
1	10	5	杨逸	1100005
1	10	1	余嘉尉	1100006
1	10	2	刘奕珞	1100007
1	10	3	张齐鑫	1100008
1	10	4	谭宇翔	1100009
1	10	5	谢豪楠	1100010
1	10	1	邱登程	1100011
1	10	2	韩艺	1100012
1	10	3	卢文灏	1100013
1	10	4	李房锦	1100014
1	10	5	张潇然	1100015
1	10	1	唐艺天	1100016
1	10	2	杜沛杰	1100017
1	10	3	李彦鲸	1100018
1	10	4	袁韬雄	1100019
1	10	5	张薇	1100020
1	10	1	龚治朋	1100021
1	10	2	刘新月	1100022
1	10	3	赵汶情	1100023
1	10	4	叶钰莎	1100024
1	10	5	董凯铭	1100025
1	10	2	吴浩正	1100026
1	10	4	唐诗华	1100027
1	10	5	曾海罗	1100028
1	10	4	曹雨	1100029

考号的编排规则为：1号为1班的第1名同学，2号为2班的第1名同学，以此类推。如果每个班人数都相等的情况下，很好解决。但是每班人数不同，该如何设计算法，准确排序。

求编排考号的程序算法

116 个解决方案

#1

排序的结果是什么形式？？？？按照学校、年级、班级排序？？？？？

#2

1号为1班的第1名同学，2号为2班的第1名同学

搞复杂了,而且搞得学号有种不连贯的感觉,可以使用下面几种排序规则
1. 先排完一班再排二班,比如:1100001~~~1100030 是一班的学号,11000031~~1100060是两班的学号
2. 在学号里融入班级代码号,比如:1101001是一班的学号,1102001是二班的学号,1103001是三班的学号
3. 先来后到法,生成10W个学号,谁先报名,就分配一个学号

#3

晕,原来是考号,不是学号
搞错搞错
略过略过

#4

目的是让同班的学生错开位置

引用 2 楼  的回复:

1号为1班的第1名同学，2号为2班的第1名同学

搞复杂了,而且搞得学号有种不连贯的感觉,可以使用下面几种排序规则
1. 先排完一班再排二班,比如:1100001~~~1100030 是一班的学号,11000031~~1100060是两班的学号
2. 在学号里融入班级代码号,比如:1101001是一班的学号,1102001是二班的学号,1103001是三班的学号
3. 先来后到法,生成……

#5

你按班级数据 提取。然后 给1 + 上学生的 ID
就完事了，没有那么复杂吧。

#6

这个和你 几班的学生没有关系好不。

#7

晕，似乎看明白了，是要排考号啊

#8

如样本数据那样排，考号为7位：
第1位：年级
第2-3位：学校代码
第4-7位：顺序号

引用 1 楼  的回复:

排序的结果是什么形式？？？？按照学校、年级、班级排序？？？？？

#9

引用 4 楼  的回复:

目的是让同班的学生错开位置引用 2 楼  的回复:

1号为1班的第1名同学，2号为2班的第1名同学

搞复杂了,而且搞得学号有种不连贯的感觉,可以使用下面几种排序规则
1. 先排完一班再排二班,比如:1100001~~~1100030 是一班的学号,11000031~~1100060是两班的学号
2. 在学号里融入班级代码号,比如:1101001是一班的学号,1102001是二班的……

嗯,看错了,如果是考号,唯一要保障的就是相邻的两个学生不是同一班就行了吧

#10

大哥，没有学生id呀

引用 5 楼  的回复:

你按班级数据 提取。然后 给1 + 上学生的 ID
就完事了，没有那么复杂吧。

#11

对的。

引用 9 楼  的回复:

引用 4 楼  的回复:

目的是让同班的学生错开位置引用 2 楼  的回复:

1号为1班的第1名同学，2号为2班的第1名同学

搞复杂了,而且搞得学号有种不连贯的感觉,可以使用下面几种排序规则
1. 先排完一班再排二班,比如:1100001~~~1100030 是一班的学号,11000031~~1100060是两班的学号
2. 在学号里融入班级代码号,比如:1101001是一……

#12

一点都不困难，见过斯瓦辛格在终结者里扛着一管加特林机枪狂扫滴吗？？

你要做的其实就是一种类似“加特林机枪”的东西，你其实根本不需要管啥人数不人数，你要做的就是不停的“旋转”填充，这个班没人了怎么？没人跳过呗，找下一班的填充

至于碰不碰撞则由数据本身绝对，你学过抽屉原则是吧，当某组数据远远大于其他组的数据，你怎么排都会碰撞。

#13

对的，就是这个思路，求实际程序算法。

引用 12 楼  的回复:

一点都不困难，见过斯瓦辛格在终结者里扛着一管加特林机枪狂扫滴吗？？

你要做的其实就是一种类似“加特林机枪”的东西，你其实根本不需要管啥人数不人数，你要做的就是不停的“旋转”填充，这个班没人了怎么？没人跳过呗，找下一班的填充

至于碰不碰撞则由数据本身绝对，你学过抽屉原则是吧，当某组数据远远大于其他组的数据，你怎么排都会碰撞。

#14

    class Program
    {
        static void Main(string[] args)
        {
            //生成模拟数据
            List<Queue<Student>> list = new List<Queue<Student>>();
            list.Add(CreateStudents(10, 1, 1));
            list.Add(CreateStudents(10, 1, 2));
            list.Add(CreateStudents(10, 1, 3));
            list.Add(CreateStudents(10, 1, 4));
            list.Add(CreateStudents(10, 1, 5));

            //存放编号结果
            List<Student> result = new List<Student>();      
            int index = 1;
            while (true)
            {
                bool isend = true;
                foreach (Queue<Student> li in list)
                {
                    if (li.Count > 0)
                    {
                        isend = false;
                        Student stu = li.Dequeue(); 
                        stu.KaoHao = 110000 + (index++);
                        result.Add(stu);
                    }
                }
                if (isend)
                    break;
            }
            //打印结果
            foreach (Student stu in result)
                Console.WriteLine(String.Format("{0} {1} {2} {3} {4}",stu.GradeID,stu.SchoolID,stu.ClassID,stu.Name,stu.KaoHao));

            Console.Read();
        }
        //生成模拟数据
        static Random random = new Random();
        static Queue<Student> CreateStudents(int SchoolID, int GradeID, int ClassID)
        {
            Queue<Student> queue = new Queue<Student>();
            int count=random.Next(20,25);
            for (int i = 0; i < count; i++)
            {
                Student stu = new Student();
                stu.SchoolID = SchoolID;
                stu.GradeID = GradeID;
                stu.ClassID = ClassID;
                stu.Name = Guid.NewGuid().ToString();
                queue.Enqueue(stu);
            }
            return queue;
        }
    }
    //学生
    class Student
    { 
        public int SchoolID;
        public int GradeID;
        public int ClassID;
        public string Name;
        public int KaoHao;
    }

#15

利用Queue<>和List<>就行了，上面的代码亲测可用，亲，给好评哦！！！！
------------------
模拟数据利用Random随机生成班级学生人数，GUID就是姓名，亲！！！

Queue<>装载班级学生，取完了count就空了！！！！

List<>装载所有班级，遍历班级就好了！！！

#16

List<Queue<Student>> list = new List<Queue<Student>>();
为什么是尖括号，这句看不懂

#17

引用 16 楼  的回复:

List<Queue<Student>> list = new List<Queue<Student>>();
为什么是尖括号，这句看不懂

就是泛型，这个你学习下相关资料就了解了，你看看测试结果是不是你想要的。

#18

List<     Queue<Student>    > list=。。。。。。。。

这下看明白了吧

#19

惭愧啊，没有学习过泛型，这下好好研究下。数据库里面的原始数据是读到数组里面还是这个泛型里面。

引用 17 楼  的回复:

引用 16 楼  的回复:

List<Queue<Student>> list = new List<Queue<Student>>();
为什么是尖括号，这句看不懂


就是泛型，这个你学习下相关资料就了解了，你看看测试结果是不是你想要的。

#20

最好是将数据库里面的数据读出来，然后装到Queue<>和List<>中，因为这样我觉得最简单了。。。

#21

说实话，以我的能力还确实看不懂，能不能封装成类。

引用 20 楼  的回复:

最好是将数据库里面的数据读出来，然后装到Queue<>和List<>中，因为这样我觉得最简单了。。。

#22

引用 21 楼  的回复:

说实话，以我的能力还确实看不懂，能不能封装成类。引用 20 楼  的回复:

最好是将数据库里面的数据读出来，然后装到Queue<>和List<>中，因为这样我觉得最简单了。。。

可以

#23

    class Program
    {
        static void Main(string[] args)
        {
            //生成模拟数据
            ClassGroup data = new ClassGroup();
            data.Add(CreateStudents(10, 1, 1));
            data.Add(CreateStudents(10, 1, 2));
            data.Add(CreateStudents(10, 1, 3));
            data.Add(CreateStudents(10, 1, 4));
            data.Add(CreateStudents(10, 1, 5));

            //存放编号结果,把所有学生假设全都填充到一个班级中
            Class result = new Class();      
            int index = 1;
            while (true)
            {
                bool isend = true;
                foreach (Class cls in data)
                {
                    if (cls.Count > 0)
                    {
                        isend = false;
                        Student stu = cls.GetStudent(); 
                        stu.KaoHao = 110000 + (index++);//生成考号
                        result.AddStudent(stu);
                    }
                }
                if (isend)
                    break;
            }
            //打印结果
            foreach (Student stu in result)
                Console.WriteLine(String.Format("{0} {1} {2} {3} {4}",stu.GradeID,stu.SchoolID,stu.ClassID,stu.Name,stu.KaoHao));

            Console.Read();
        }
        //生成模拟数据
        static Random random = new Random();
        static Class CreateStudents(int SchoolID, int GradeID, int ClassID)
        {
            Class cls = new Class();
            int count=random.Next(20,25);
            for (int i = 0; i < count; i++)
            {
                Student stu = new Student();
                stu.SchoolID = SchoolID;
                stu.GradeID = GradeID;
                stu.ClassID = ClassID;
                stu.Name = Guid.NewGuid().ToString();
                cls.AddStudent(stu);
            }
            return cls;
        }
    }
    //所有班级
    class ClassGroup : List<Class>
    {
        public void AddClass(Class cls)
        {
            this.Add(cls);
        }
    }
    //班级
    class Class : Queue<Student>
    {
        public void AddStudent(Student stu)
        {
            this.Enqueue(stu);
        }
        public Student GetStudent()
        {
            return this.Dequeue();
        }
    }
    //学生
    class Student
    { 
        public int SchoolID;
        public int GradeID;
        public int ClassID;
        public string Name;
        public int KaoHao;
    }

#24

下面简单封装的class你不用关心，代码里没有尖括号了，我能写的就这么多了

#25

马甲一下

#26

还能再简单点，这样你能使用方便点：

   class Program
    {
        static void Main(string[] args)
        {
            //生成模拟数据
            ClassGroup data = new ClassGroup();
            data.Add(CreateStudents(10, 1, 1));
            data.Add(CreateStudents(10, 1, 2));
            data.Add(CreateStudents(10, 1, 3));
            data.Add(CreateStudents(10, 1, 4));
            data.Add(CreateStudents(10, 1, 5));

            //存放编号结果,把所有学生假设全都填充到一个班级中
            Class result = data.CreateKaoHao(); //生成考号     
           
            //打印结果
            foreach (Student stu in result)
                Console.WriteLine(String.Format("{0} {1} {2} {3} {4}",stu.GradeID,stu.SchoolID,stu.ClassID,stu.Name,stu.KaoHao));

            Console.Read();
        }
        //生成模拟数据
        static Random random = new Random();
        static Class CreateStudents(int SchoolID, int GradeID, int ClassID)
        {
            Class cls = new Class();
            int count=random.Next(20,25);
            for (int i = 0; i < count; i++)
            {
                Student stu = new Student();
                stu.SchoolID = SchoolID;
                stu.GradeID = GradeID;
                stu.ClassID = ClassID;
                stu.Name = Guid.NewGuid().ToString();
                cls.AddStudent(stu);
            }
            return cls;
        }
    }
    //所有班级
    class ClassGroup : List<Class>
    {
        public void AddClass(Class cls)
        {
            this.Add(cls);
        }
        public Class CreateKaoHao()
        {
            Class result = new Class();    
            int index = 1;
            while (true)
            {
                bool isend = true;
                foreach (Class cls in this)
                {
                    if (cls.Count > 0)
                    {
                        isend = false;
                        Student stu = cls.GetStudent();
                        stu.KaoHao = 110000 + (index++);//生成考号
                        result.AddStudent(stu);
                    }
                }
                if (isend)
                    break;
            }
            return result;
        }
    }
    //班级
    class Class : Queue<Student>
    {
        public void AddStudent(Student stu)
        {
            this.Enqueue(stu);
        }
        public Student GetStudent()
        {
            return this.Dequeue();
        }
    }
    //学生
    class Student
    { 
        public int SchoolID;
        public int GradeID;
        public int ClassID;
        public string Name;
        public int KaoHao;
    }

#27

大侠，可能误解题意了，原始学生数据是固定的，排列方式是按班级从小到大排列，我看这个程序的学生数据是按照班级1、2、3、4、5这样依次生成的呢？

引用 26 楼  的回复:

还能再简单点，这样你能使用方便点：
C# code
   class Program
    {
        static void Main(string[] args)
        {
            //生成模拟数据
            ClassGroup data = new ClassGroup();
            data.Add(CreateSt……

#28

最简单的方法：根据班级groupby，然后for循环遍历每个班级，拿出第I条数据放到，直到所有的班级都分配
完

当然，不能保证所有的紧挨着的同学都来自不同班级
假设：一共三个班，1班有3人，2班有5人，3班50人，怎么分也不可能保证所有的紧挨着的同学都来自不同班级。

#29

这个可以明确告诉楼主，是不可能实现完全错开的！

现实中应该根据具体班级数目（年级是否一样）、各班学生人数手工确定原则，再由电脑来安排才能获得最佳效果

#30

用数组还是用什么，是读数据到 datatalbe 里面，还是通过 在sqlserver里面写存储过程来完成。

引用 28 楼  的回复:

最简单的方法：根据班级groupby，然后for循环遍历每个班级，拿出第I条数据放到，直到所有的班级都分配
完

#31

题目很有意思  

我下来做了尝试  

做了三个班级  每个班级学生个数都不相同  

思路如下  目的我们是要给每个学生都赋予考号  而要让各个班级学生尽量错开  我是这样处理的
把三个班级学生 人数最多的班级拿来当做循环变量  因为我们循环就需要跑那么多次

做一个考号的全局变量  每次给学生赋予考号的时候我们可以吧这个考号+1
循环中这样判断  如果1班的人数少于循环目前次数  证明这班目前就这么多人 没学生需要赋给考号了  跳过

我把每个学生放到数组 遍历结果 确实是我们需要的结果  如下 
1班学生0   1000001
2班学生0   1000002
3班学生0   1000003
1班学生1   1000004
2班学生1   1000005
3班学生1   1000006
1班学生2   1000007
2班学生2   1000008
3班学生2   1000009
1班学生3   1000010
2班学生3   1000011
3班学生3   1000012
1班学生4   1000013
2班学生4   1000014
3班学生4   1000015
1班学生5   1000016
2班学生5   1000017
3班学生5   1000018
1班学生6   1000019
2班学生6   1000020
3班学生6   1000021
1班学生7   1000022
2班学生7   1000023
3班学生7   1000024
1班学生8   1000025
2班学生8   1000026
3班学生8   1000027
1班学生9   1000028
2班学生9   1000029
3班学生9   1000030
1班学生10   1000031
2班学生10   1000032
3班学生10   1000033
1班学生11   1000034
2班学生11   1000035
3班学生11   1000036
1班学生12   1000037
2班学生12   1000038
3班学生12   1000039
1班学生13   1000040
2班学生13   1000041
3班学生13   1000042
1班学生14   1000043
2班学生14   1000044
3班学生14   1000045
1班学生15   1000046
2班学生15   1000047
3班学生15   1000048
1班学生16   1000049
2班学生16   1000050
3班学生16   1000051
1班学生17   1000052
2班学生17   1000053
3班学生17   1000054
1班学生18   1000055
2班学生18   1000056
3班学生18   1000057
1班学生19   1000058
2班学生19   1000059
3班学生19   1000060
1班学生20   1000061
2班学生20   1000062
3班学生20   1000063
1班学生21   1000064
2班学生21   1000065
3班学生21   1000066
1班学生22   1000067
2班学生22   1000068
3班学生22   1000069
1班学生23   1000070
2班学生23   1000071
3班学生23   1000072
1班学生24   1000073
2班学生24   1000074
3班学生24   1000075
1班学生25   1000076
2班学生25   1000077
3班学生25   1000078
1班学生26   1000079
2班学生26   1000080
3班学生26   1000081
1班学生27   1000082
2班学生27   1000083
3班学生27   1000084
1班学生28   1000085
2班学生28   1000086
3班学生28   1000087
1班学生29   1000088
2班学生29   1000089
2班学生30   1000090
2班学生31   1000091
2班学生32   1000092
2班学生33   1000093


主要代码
 static void Main(string[] args)
        {

            Student[] class1 = new Student[30];
            for (int i = 0; i < class1.Length; i++)
            {
                class1[i]=new Student();
                class1[i].Name = "1班学生" + i.ToString();   
            }

            Student[] class2 = new Student[34];
            for (int i = 0; i < class2.Length; i++)
            {
                class2[i] = new Student();
                class2[i].Name = "2班学生" + i.ToString();

            }

            Student[] class3 = new Student[29];
            for (int i = 0; i < class3.Length; i++)
            {
                class3[i] = new Student();
                class3[i].Name = "3班学生" + i.ToString();

            }
            List<Student[]> all = new List<Student[]>();
            all.Add(class1);
            all.Add(class2);
            all.Add(class3);
            List<Student> alls=GiveStudentKH(all);
            foreach (Student s in alls)
            {
                Console.WriteLine(s.Name+"   "+s.KH.ToString());
            }
            Console.Read();

        }
         public static List<Student> GiveStudentKH(List<Student[]> all)
        {
            int length = all.Count;
            int allstudentlength=0;
            Student[] c1 = all[0];
            Student[] c2 = all[1];
            Student[] c3 = all[2];
            allstudentlength = c1.Length + c2.Length + c3.Length;
            List<Student> allstudent = new List<Student>();
            int x = 0;
           // int classstudentNumber=0;
            int KH=1000000;
            for (int i = 0; i < c2.Length; i++)
            {
                
                    if (i <c1.Length)
                    {
                        KH = KH + 1;
                        all[0][i].KH = KH;
                        allstudent.Add(all[0][i]);
                    }
                    if (i < c2.Length)
                    {
                        KH = KH + 1;
                        all[1][i].KH = KH;
                        allstudent.Add(all[1][i]);
                    }   
              
                    if (i < c3.Length)
                    {
                        KH = KH + 1;
                        all[2][i].KH = KH;
                        allstudent.Add(all[2][i]);
                    }
         

            }

            return allstudent;

        }

       
    }
    public class Student
    {
        string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        int classid;

        public int Classid
        {
            get { return classid; }
            set { classid = value; }
        }
        int kH;

        public int KH
        {
            get { return kH; }
            set { kH = value; }
        }

    }
有些代码是当时测试其他方式写的 自行整理

#32

看来还得要用到泛型，要补充泛型的知识了

引用 31 楼  的回复:

题目很有意思  

我下来做了尝试  

做了三个班级  每个班级学生个数都不相同  

思路如下  目的我们是要给每个学生都赋予考号  而要让各个班级学生尽量错开  我是这样处理的
把三个班级学生 人数最多的班级拿来当做循环变量  因为我们循环就需要跑那么多次

做一个考号的全局变量  每次给学生赋予考号的时候我们可以吧这个考号+1
循环中这样判断  如果1班的人数少于循环……

#33

该回复于2014-04-10 22:56:02被版主删除

#34

引用 12 楼  的回复:

一点都不困难，见过斯瓦辛格在终结者里扛着一管加特林机枪狂扫滴吗？？

你要做的其实就是一种类似“加特林机枪”的东西，你其实根本不需要管啥人数不人数，你要做的就是不停的“旋转”填充，这个班没人了怎么？没人跳过呗，找下一班的填充

至于碰不碰撞则由数据本身绝对，你学过抽屉原则是吧，当某组数据远远大于其他组的数据，你怎么排都会碰撞。

up

#35

引用 32 楼  的回复:

看来还得要用到泛型，要补充泛型的知识了引用 31 楼  的回复:

题目很有意思

我下来做了尝试

做了三个班级  每个班级学生个数都不相同

思路如下  目的我们是要给每个学生都赋予考号  而要让各个班级学生尽量错开  我是这样处理的
把三个班级学生 人数最多的班级拿来当做循环变量  因为我们循环就需要跑那么多次

做一个考号的全局变量  每次给学生赋予考号的时候我们可……

其实不难理解的  用习惯了 会觉得很好用

#36

这个定义了个啥玩意，类？

public class Student

引用 35 楼  的回复:

引用 32 楼  的回复:

看来还得要用到泛型，要补充泛型的知识了引用 31 楼  的回复:

题目很有意思

我下来做了尝试

做了三个班级  每个班级学生个数都不相同

思路如下  目的我们是要给每个学生都赋予考号  而要让各个班级学生尽量错开  我是这样处理的
把三个班级学生 人数最多的班级拿来当做循环变量  因为我们循环就需要跑那么多次

做一个考号的全局变量……

#37

要读数据进来的话，也要读到这个 class 里面

#38

假设 a代表此学生在班级里顺序号， b 代表班级在年级里的顺序号，c代表年级学校里的顺序号，d代表学校的顺序编号，那么你就按照

(from x in 学生资料
orderby a,b,c,d
select x).ToList()

的方式得到新的列表，然后for循环给所有学生重新编顺序号（从1到29）即可。

#39

只是要注意orderby的顺序，哪里用得着写那么复杂的程序？

#40

没有班内的顺序号，那么你需要为学生资料先设置一个顺序号（相信这个对你不难）。然后的操作也很简单，如果写具体一点，类似于

var lst=(from x in 学生资料
orderby 班内顺序号,班级,年级,学校代码
select x).ToList();
for(var i= 0; i<lst.Count; i++)
    lst[i].考试顺序 = i;

#41

大神，用sql查询吗？

引用 39 楼  的回复:

只是要注意orderby的顺序，哪里用得着写那么复杂的程序？

#42

引用 40 楼  的回复:

没有班内的顺序号，那么你需要为学生资料先设置一个顺序号（相信这个对你不难）。然后的操作也很简单，如果写具体一点，类似于

C# code
var lst=(from x in 学生资料
orderby 班内顺序号,班级,年级,学校代码
select x).ToList();
for(var i= 0; i<lst.Count; i++)
    lst[i].考试顺序 = i;

这没有考虑每班人数不同、年级里班级不同、学校里年级不同的情况。我觉得还是不够实用。

仅供参考而已。我觉得这个还是有错的！

#43

其实要是我，就简单地写个代码

var rnd = new Random();
var lst=(from x in 学生资料
orderby rnd.Next()
select x).ToList();
for(var i= 0; i<lst.Count; i++)
  lst[i].考试顺序 = i;

这就得了，管它同班同学相邻不相邻的呢？！

#44

要求同班学生尽量错开，没得办法啊

引用 43 楼  的回复:

其实要是我，就简单地写个代码C# code
var rnd = new Random();
var lst=(from x in 学生资料
orderby rnd.Next()
select x).ToList();
for(var i= 0; i<lst.Count; i++)
  lst[i].考试顺序 = i;
这就得了，管它同班同学相邻不相邻的呢？！

#45

难道还不够“尽量错开”吗？

那么也是以这个为前提，再做个别调整。

#46

尽量错开的意思是，有班级分完了的情况

引用 45 楼  的回复:

难道还不够“尽量错开”吗？

那么也是以这个为前提，再做个别调整。

#47

原来是linq

引用 44 楼  的回复:

要求同班学生尽量错开，没得办法啊引用 43 楼  的回复:

其实要是我，就简单地写个代码C# code
var rnd = new Random();
var lst=(from x in 学生资料
orderby rnd.Next()
select x).ToList();
for(var i= 0; i<lst.Count; i++)
  lst[i].考试顺序 = i;
……

#48

引用 27 楼  的回复:

大侠，可能误解题意了，原始学生数据是固定的，排列方式是按班级从小到大排列，我看这个程序的学生数据是按照班级1、2、3、4、5这样依次生成的呢？引用 26 楼  的回复:

还能再简单点，这样你能使用方便点：
C# code
class Program
{
static void Main(string[] args)
{
//生成模拟数据
ClassGroup data = n……

我那只是生成模拟数据，我不可能花那么多时间去做一个固定的学生数据库，我不生成模拟数据，怎么测试生成考号，你基础知识差的比较多，楼上诸多大神的回复估计你也是看不懂。

#49

            //生成模拟数据
            ClassGroup data = new ClassGroup();
            data.Add(CreateStudents(10, 1, 1));
            data.Add(CreateStudents(10, 1, 2));
            data.Add(CreateStudents(10, 1, 3));
            data.Add(CreateStudents(10, 1, 4));
            data.Add(CreateStudents(10, 1, 5));

这个只是模拟你的学生数据库，你可能有许多班级，这里生成了5个班级，每个班级学生个数不一样，这样不就能测试了么

#50

先统计出人数最多的班，统计总人数，再计算出每个班的同学出现间隔