结对编程作业——毕设导师智能匹配

最新推荐文章于 2024-06-17 17:27:13 发布
最新推荐文章于 2024-06-17 17:27:13 发布
阅读量114 收藏 1
点赞数
文章标签： git 开发工具 数据库
原文链接：http://www.cnblogs.com/yc-chen/p/5924887.html
版权

031402504 陈逸超
031402426 许秋鑫

毕设导师智能匹配

问题描述以及实现要求

编码实现一个毕设导师的智能匹配的程序，要求如下：

  • 输入要求：30个老师（包含带学生数的要求的上限，单个数值，在[0,8]内），100个学生（包含绩点信息），每个学生有5个导师志愿（志愿的导师可以重复但不能空缺）。
  • 实现一个智能自动分配算法，根据输入信息，输出导师和学生间的匹配信息。
  • 输出要求：输出学生导师分配情况，以及未被分配到导师的学生和未被分配到学生的导师，要求一个学生只能有一个确认导师，一个导师可以带少于等于其要求的学生数的学生。

实现要求：

  • 输入的数据，另外写生成程序随机实现。
  • 为输入输出设计标准化、通用化、可扩展的接口，为该智能匹配程序模块后期可能的整合入系统提供便利。
  • 输入输出的格式，如采用文本文件或数据库的方式输入，可自由讨论确定，但需要明确，为后期可能的整合入系统提供便利。
  • 需要为智能匹配算法确立几条分配或排序原则。
  • 算法评价的目标是：对于同一组输入，输出的未被导师选中的学生数越少越好。
  • 代码具有规范性。
  • 实现的程序语言不做限制性要求。
  • 代码提交在https://coding.net 上。
  • 两个人共同撰写一个博客，包含上述内容的描述，同时包含结对感受，以及两个人对彼此结对中的闪光点或建议的分享。

问题分析

根据问题的描述以及实现要求，我们讨论得出完成毕设导师智能匹配系统要进行的步骤：
UHbn4RS.png

代码分析

学生类和导师类

public class Student {
private int sNumber;//学号
private double score;//绩点
private int[]tNumber = new int[5];//五个志愿
private Boolean isHaveTutor;//是否有导师
private int selectedTutorNumber;//中选导师编号
public class Turtor implements Comparable<Turtor> {

private int tNumber;// 教师职工号
private int limitCount;// 限制所带学生数
private int selectedCount;// 有多少学生在志愿中选择该导师
private Boolean isHaveStudent;//是否有学生选择该导师
private TreeMap<Double, String> compositeValue;// 学生的综合值
private double popularityRatio;// 热度比

随机生成输入数据类

public class InputProduct {
private static int[] tNumber = new int[31];// 教师职工号
private static int[] limitCount = new int[31];// 限制所带学生数
private static int[] sNumber = new int[101];// 学号
private static double[] score = new double[101];// 绩点
private static int[][] wtNumber = new int[101][5];// 五个志愿

public static void main(String[] args) throws FileNotFoundException {
    // TODO Auto-generated method stub
    boolean[] bool = new boolean[131];
    Random rand = new Random();
    // IO流，将随机生成的数据保存到本地txt文件
    FileOutputStream out = new FileOutputStream("tData.txt", true);
    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));
    for (int i = 1; i < 31; i++) {

        do {
            tNumber[i] = rand.nextInt(30);//随机生成导师职工号
        } while (bool[tNumber[i]]);
        bool[tNumber[i]] = true;
        limitCount[i] = rand.nextInt(9);//随机生成教师限带学生数
        // 保存到txt文件的工具类，保存教师信息
        ToolsDataDeal.saveTData(String.valueOf(tNumber[i]), String.valueOf(limitCount[i]), out, writer);
    }
    try {
        if (writer != null) {
            writer.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    boolean[] sbool = new boolean[101];
    // IO流，将随机生成的数据保存到本地txt文件
    out = new FileOutputStream("sData.txt", true);
    writer = new BufferedWriter(new OutputStreamWriter(out));
    for (int i = 1; i < 101; i++) {

        do {
            sNumber[i] = rand.nextInt(100);//随机生成学生学号
        } while (sbool[sNumber[i]]);
        sbool[sNumber[i]] = true;
        score[i] = rand.nextDouble() * 5;//随机生成学生绩点成绩
        for (int j = 0; j < 5; j++)
            wtNumber[i][j] = rand.nextInt(30);//随机生成学生的五个志愿
        //保存到txt文件的工具类，将学生数据保存到txt文件
        ToolsDataDeal.saveSData(out, writer, String.valueOf(sNumber[i]), String.valueOf(score[i]),
                String.valueOf(wtNumber[i][0]), String.valueOf(wtNumber[i][1]), String.valueOf(wtNumber[i][2]),
                String.valueOf(wtNumber[i][3]), String.valueOf(wtNumber[i][4]));
    }
    try {
        if (writer != null) {
            writer.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
  }
}

输入数据保存到txt文件的工具类

public class ToolsDataDeal {

//保存导师随机生成数据的函数
public static void saveTData(String tNumber, String limitCount, FileOutputStream out, BufferedWriter writer) {
    try {
        writer.write(tNumber);
        writer.newLine();
        writer.write(limitCount);
        writer.newLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

//保存学生随机生成数据的函数
public static void saveSData(FileOutputStream out, BufferedWriter writer, String sNumber, String score,
        String application1, String application2, String application3, String application4, String application5) {
    try {
        writer.write(sNumber);
        writer.newLine();
        writer.write(score);
        writer.newLine();
        writer.write(application1);
        writer.newLine();
        writer.write(application2);
        writer.newLine();
        writer.write(application3);
        writer.newLine();
        writer.write(application4);
        writer.newLine();
        writer.write(application5);
        writer.newLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

//加载学生数据到学生对象数组的函数
public static void loadSdata(Student s, FileInputStream in, BufferedReader reader) {
    String line = null;
    int[] tNmuber = new int[5];
    try {
        for (int i = 0; i < 7; i++) {
            if ((line = reader.readLine()) != null) {
                switch (i) {
                case 0:
                    s.setsNumber(Integer.parseInt(line));
                    break;
                case 1:
                    s.setScore(Double.parseDouble(line));
                    break;
                case 2:
                    tNmuber[0] = Integer.parseInt(line);
                    break;
                case 3:
                    tNmuber[1] = Integer.parseInt(line);
                    break;
                case 4:
                    tNmuber[2] = Integer.parseInt(line);
                    break;
                case 5:
                    tNmuber[3] = Integer.parseInt(line);
                    break;
                case 6:
                    tNmuber[4] = Integer.parseInt(line);
                    break;
                }

            }
        }
        s.settNmuber(tNmuber);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

//加载导师数据到导师对象数组的函数
public static void loadTdata(Turtor t, FileInputStream in, BufferedReader reader) {
    String line = null;
    try {
        for (int i = 0; i < 2; i++) {
            if ((line = reader.readLine()) != null) {
                switch (i) {
                case 0:
                    t.settNumber(Integer.parseInt(line));
                    break;
                case 1:
                    t.setLimitCount(Integer.parseInt(line));
                    break;
                }
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
  }

}

匹配算法

算法的设计描述如下：
1.我们定义每个学生都有一个综合值compositeScore=0.8score+0.2gradient[x]；(score代表学生的绩点，gradient[x]代表第x个志愿对应的值，其中x=1,2,3,4,5分别为3.0,2.5,2.0，1.5,1)
2.对于老师定义一个热度比popularity=selectedCount/limit(limit:老师的限选人数
selectedCount：有多少个学生填报志愿的时候选择了该老师)
3.算法实现过程：

  • 计算各个学生的compositeScore。
  • 计算各个老师的popularity并且排序，排序方式为升序。
  • 做30次选取导师，每次选取一名导师来分配给该导师学生，30次选取分为六部分的选取，第一部分从导师序列中的第一到五名导师中选取，第二部分从30名到26名选取，第三部分从20名到16名中选取，第四部分从第6名到第10名中选取，第五部分从第25名到第21名中选取，第六部分从第11名到15名中选取。
  • 导师选取学生的原则是按照综合值从低到高选取的

算法实现代码如下：
public class TurtorSelect {

public static void main(String[] args) throws FileNotFoundException {
    // 数据录入
    Student[] s = new Student[100];
    Turtor[] t = new Turtor[30];
    loadData(s, t);
    /*
     * 匹配算法
     */
    Match(s, t);

}

private static void Match(Student[] s, Turtor[] t) {
    // 1、创表,计算每个导师的所有学生的综合值
    createCompositeScoreTable(s, t);
    // 2、计算热度并选出导师
    calpopularity(t);
    // 3、按照导师热度比从低到高分配学生
    matchStudent(s, t);
    // 4、输出分配结果
    outputMatchResult(s, t);

}

private static void outputMatchResult(Student[] s, Turtor[] t) {
    // TODO Auto-generated method stub
    System.out.println("已被分配的学生及其导师情况：");
    for (int i = 0; i < 100; i++) {
        if (s[i].getIsHaveTutor() == true) {
            System.out.println("学生号为：" + s[i].getsNumber() + "导师号为：" + s[i].getSelectedTutorNumber() + "学生绩点："
                    + s[i].getScore() + "导师热度比：" + t[s[i].getSelectedTutorNumber()].getPopularityRatio());
        }
    }
    System.out.println("未被分配导师的学生：");
    for (int i = 0; i < 100; i++) {
        if (s[i].getIsHaveTutor() == false) {
            System.out.print("" + s[i].getsNumber() + ";");
        }
    }
    System.out.println("未被分配学生的导师：");
    for (int i = 0; i < 30; i++) {
        if (t[i].getIsHaveStudent() == false) {
            System.out.println("" + t[i].gettNumber() + ";" + t[i].getPopularityRatio());
        }
    }
}

private static void matchStudent(Student[] s, Turtor[] t) {
    // TODO Auto-generated method stub
    int n;
    Boolean b;
    for (int k = 0; k < 5; k++) {
        Set set = t[k].getCompositeValue().entrySet();
        Iterator it = set.iterator();
        if (t[k].getSelectedCount() > t[k].getLimitCount()) {
            n = t[k].getLimitCount();
        } else {
            n = t[k].getSelectedCount();
        }
        if (t[k].getLimitCount() != 0) {
            for (int i = 0; i < n; i++) {
                if (it.hasNext()) {
                    Map.Entry set1 = (Entry) it.next();
                    /*
                     * System.out.println(Integer.parseInt((String)
                     * set1.getValue()));
                     * System.out.println(t[0].getCompositeValue());
                     */
                    if (s[Integer.parseInt((String) set1.getValue())].getIsHaveTutor() == false) {
                        b = true;
                        t[k].setIsHaveStudent(true);
                        s[Integer.parseInt((String) set1.getValue())].setIsHaveTutor(b);
                        s[Integer.parseInt((String) set1.getValue())].setSelectedTutorNumber(t[k].gettNumber());
                        /*
                         * System.out.println(t[k].gettNumber()+";"+Integer.
                         * parseInt((String) set1.getValue()));
                         */
                    } else {
                        i--;
                    }
                } else {
                    break;
                }

            }
        }
    }
    for (int k = 29; k >= 25; k--) {
        Set set = t[k].getCompositeValue().entrySet();
        Iterator it = set.iterator();
        if (t[k].getSelectedCount() > t[k].getLimitCount()) {
            n = t[k].getLimitCount();
        } else {
            n = t[k].getSelectedCount();
        }
        if (t[k].getLimitCount() != 0) {
            for (int i = 0; i < n; i++) {
                if (it.hasNext()) {
                    Map.Entry set1 = (Entry) it.next();
                    /*
                     * System.out.println(Integer.parseInt((String)
                     * set1.getValue()));
                     * System.out.println(t[0].getCompositeValue());
                     */
                    if (s[Integer.parseInt((String) set1.getValue())].getIsHaveTutor() == false) {
                        b = true;
                        t[k].setIsHaveStudent(true);
                        s[Integer.parseInt((String) set1.getValue())].setIsHaveTutor(b);
                        s[Integer.parseInt((String) set1.getValue())].setSelectedTutorNumber(t[k].gettNumber());
                        /*
                         * System.out.println(t[k].gettNumber()+";"+Integer.
                         * parseInt((String) set1.getValue()));
                         */
                    } else {
                        i--;
                    }
                } else {
                    break;
                }

            }
        }
    }
    for (int k = 19; k >= 15; k--) {
        Set set = t[k].getCompositeValue().entrySet();
        Iterator it = set.iterator();
        if (t[k].getSelectedCount() > t[k].getLimitCount()) {
            n = t[k].getLimitCount();
        } else {
            n = t[k].getSelectedCount();
        }
        if (t[k].getLimitCount() != 0) {
            for (int i = 0; i < n; i++) {
                if (it.hasNext()) {
                    Map.Entry set1 = (Entry) it.next();
                    /*
                     * System.out.println(Integer.parseInt((String)
                     * set1.getValue()));
                     * System.out.println(t[0].getCompositeValue());
                     */
                    if (s[Integer.parseInt((String) set1.getValue())].getIsHaveTutor() == false) {
                        b = true;
                        t[k].setIsHaveStudent(true);
                        s[Integer.parseInt((String) set1.getValue())].setIsHaveTutor(b);
                        s[Integer.parseInt((String) set1.getValue())].setSelectedTutorNumber(t[k].gettNumber());
                        /*
                         * System.out.println(t[k].gettNumber()+";"+Integer.
                         * parseInt((String) set1.getValue()));
                         */
                    } else {
                        i--;
                    }
                } else {
                    break;
                }

            }
        }
    }
    for (int k = 5; k <= 9; k++) {
        Set set = t[k].getCompositeValue().entrySet();
        Iterator it = set.iterator();
        if (t[k].getSelectedCount() > t[k].getLimitCount()) {
            n = t[k].getLimitCount();
        } else {
            n = t[k].getSelectedCount();
        }
        if (t[k].getLimitCount() != 0) {
            for (int i = 0; i < n; i++) {
                if (it.hasNext()) {
                    Map.Entry set1 = (Entry) it.next();
                    /*
                     * System.out.println(Integer.parseInt((String)
                     * set1.getValue()));
                     * System.out.println(t[0].getCompositeValue());
                     */
                    if (s[Integer.parseInt((String) set1.getValue())].getIsHaveTutor() == false) {
                        b = true;
                        t[k].setIsHaveStudent(true);
                        s[Integer.parseInt((String) set1.getValue())].setIsHaveTutor(b);
                        s[Integer.parseInt((String) set1.getValue())].setSelectedTutorNumber(t[k].gettNumber());
                        /*
                         * System.out.println(t[k].gettNumber()+";"+Integer.
                         * parseInt((String) set1.getValue()));
                         */
                    } else {
                        i--;
                    }
                } else {
                    break;
                }

            }
        }
    }
    for (int k = 14; k >= 10; k--) {
        Set set = t[k].getCompositeValue().entrySet();
        Iterator it = set.iterator();
        if (t[k].getSelectedCount() > t[k].getLimitCount()) {
            n = t[k].getLimitCount();
        } else {
            n = t[k].getSelectedCount();
        }
        if (t[k].getLimitCount() != 0) {
            for (int i = 0; i < n; i++) {
                if (it.hasNext()) {
                    Map.Entry set1 = (Entry) it.next();
                    /*
                     * System.out.println(Integer.parseInt((String)
                     * set1.getValue()));
                     * System.out.println(t[0].getCompositeValue());
                     */
                    if (s[Integer.parseInt((String) set1.getValue())].getIsHaveTutor() == false) {
                        b = true;
                        t[k].setIsHaveStudent(true);
                        s[Integer.parseInt((String) set1.getValue())].setIsHaveTutor(b);
                        s[Integer.parseInt((String) set1.getValue())].setSelectedTutorNumber(t[k].gettNumber());
                        /*
                         * System.out.println(t[k].gettNumber()+";"+Integer.
                         * parseInt((String) set1.getValue()));
                         */
                    } else {
                        i--;
                    }
                } else {
                    break;
                }

            }
        }
    }
    for (int k = 24; k >= 20; k--) {
        Set set = t[k].getCompositeValue().entrySet();
        Iterator it = set.iterator();
        if (t[k].getSelectedCount() > t[k].getLimitCount()) {
            n = t[k].getLimitCount();
        } else {
            n = t[k].getSelectedCount();
        }
        if (t[k].getLimitCount() != 0) {
            for (int i = 0; i < n; i++) {
                if (it.hasNext()) {
                    Map.Entry set1 = (Entry) it.next();
                    /*
                     * System.out.println(Integer.parseInt((String)
                     * set1.getValue()));
                     * System.out.println(t[0].getCompositeValue());
                     */
                    if (s[Integer.parseInt((String) set1.getValue())].getIsHaveTutor() == false) {
                        b = true;
                        t[k].setIsHaveStudent(true);
                        s[Integer.parseInt((String) set1.getValue())].setIsHaveTutor(b);
                        s[Integer.parseInt((String) set1.getValue())].setSelectedTutorNumber(t[k].gettNumber());
                        /*
                         * System.out.println(t[k].gettNumber()+";"+Integer.
                         * parseInt((String) set1.getValue()));
                         */
                    } else {
                        i--;
                    }
                } else {
                    break;
                }

            }
        }
    }
}

private static void calpopularity(Turtor[] t) {
    // TODO Auto-generated method stub
    for (int i = 0; i < 30; i++) {
        if (t[i].getLimitCount() != 0) {
            t[i].setPopularityRatio((double) t[i].getSelectedCount() / (double) t[i].getLimitCount());
        } else {
            t[i].setPopularityRatio(100000);// 设置为一个较大的值
        }
    }
    Arrays.sort(t);
    /*
     * for(int i=0;i<30;i++)
     * System.out.println(t[i].getPopularityRatio()+";"+t[i].gettNumber()+
     * ";"+t[i].getSelectedCount()+";"+t[i].getLimitCount());
     */
}

private static void createCompositeScoreTable(Student[] s, Turtor[] t) {
    // TODO Auto-generated method stub
    double[] gradient = { 3, 2.5, 2, 1.5, 1 };
    for (int i = 0; i < 30; i++) {
        HashMap<Double, String> map = new HashMap<Double, String>();
        /*
         * CompositeValueComparator cvc = new CompositeValueComparator(map);
         */
        TreeMap<Double, String> sortedMap = new TreeMap<Double, String>();
        t[i].setCompositeValue(sortedMap);
    }

    for (int i = 0; i < 100; i++) {

        for (int j = 0; j < 5; j++) {
            double compositeScore = s[i].getScore() * 0.8 + gradient[j] * 0.2;
            t[s[i].gettNmuber()[j]].getCompositeValue().put(compositeScore, s[i].getsNumber() + "");
            t[s[i].gettNmuber()[j]].selectedCountAdd();

        }

    }

}

private static void loadData(Student[] s, Turtor[] t) throws FileNotFoundException {
    // TODO Auto-generated method stubam("s
    FileInputStream in = new FileInputStream("sData.txt");
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    for (int i = 0; i < 100; i++) {
        s[i] = new Student();
        s[i].setIsHaveTutor(false);
        ToolsDataDeal.loadSdata(s[i], in, reader);
    }
    if (reader != null) {
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
     * System.out.println(s[2].getsNumber());
     * System.out.println(s[2].getScore());
     * System.out.println(s[2].gettNmuber()[0]);
     * System.out.println(s[2].gettNmuber()[1]);
     * System.out.println(s[2].gettNmuber()[2]);
     * System.out.println(s[2].gettNmuber()[3]);
     * System.out.println(s[2].gettNmuber()[4]);
     */
    in = new FileInputStream("tData.txt");
    reader = new BufferedReader(new InputStreamReader(in));

    for (int i = 0; i < 30; i++) {
        t[i] = new Turtor();
        t[i].setIsHaveStudent(false);
        ToolsDataDeal.loadTdata(t[i], in, reader);
    }
    /*
     * System.out.println(t[2].gettNumber());
     * System.out.println(t[2].getLimitCount());
     */

}

}

运行结果
jNnAAiF.png
从图表中可以看出学生被分配到导师的比例超过90%，几乎每个学生都能被分配到学生
算法合理性
1.选取导师合理性：算法整体上，从热度低的老师先开始选取学生，易知这样可以使未被匹配到的导师和学生人数减少。
2.导师选取学生合理性；一般来讲，热度越小的导师，一般是绩点越低的学生选取，而绩点较高的学生选取热度较低的导师，综合分一般较高，一般情况下绩点低的学生较难被匹配，，所以我们导师选取学生是从综合分低到高选取，可以使绩点较低的学生先被选取，这样可以整体上使未被匹配到的导师和学生人数减少。
3.采用分层方式选取导师合理性：如果按照原则1选取导师，那么应该直接热度从低到高选取，但是如果这样的话，那些热度高的导师，反而选不到或者选很少的学生，所以我们采用了分层选取，也就是分6部分选取，这样能够有效避免热度高的导师反而选不到学生。

总结

从栋哥把题目发出来的那天开始，我和我的队友就在想要怎么实现。想了一两天都毫无头绪，表示很慌！第三天的时候，我们讨论了一下决定采用这个算法（其实我们编码的第二天有听到同学在给我们介绍可以使用二分匹配这种高大上的算法）。可是想想，我们这个算法已经实现了一半了，而且也是自己思考出来的一个方法，虽然方法土了一点，再怎么说也是自己想出来的，要把它实现了，至于算法的好坏，看天意了。即使很差，也是我们认真思考的成果，实现完之后，看看算法计算的结果也不算太差。
这次我们两个人的收获呢？一个是，我们相互讨论，在讨论的过程中，分享我和队友之间的想法，思维的碰撞觉得挺好的，头脑风暴，把自己的idea说出来，和别人的idea对比一下，就这样idea就会越想越多。第二个就是，学会git的使用，和把代码托管到coding.net上面！git很强大，当然我们没有死记硬背的把那些命令背下来，我们熟悉了git怎么使用，把那些好的git的介绍博客收藏起来了，我相信在之后的重复使用git中，我们会对git有更深的认识。

结对感受

  • 许秋鑫：经过这次结对编程，我了解到了合作的重要性，特别是提出自己的想法，一定要自己好好的表达，不然会导致同伴理解不清，会给合作留下很多的隐患。
  • 陈逸超：两个人总比一个人强！很赞同栋哥说过的，结对编程的效率会提高。我和小伙伴在编程的时候，当我码错了，我的小伙伴就会提醒我，我亦如此。还有一个就是，两个人一起码代码会专心很多，不会被外在的东西打扰。当然还有一点咯，累了就换小伙伴上，可以劳逸结合！~

闪光点

  • 许秋鑫：提出算法整体上先从热度较低的老师开始分配学生，在为每一个导师分配学生的时候，按照学生综合值从低到高分配学生，可以使尽可能多的学生有导师。
  • 陈逸超：定义绩点乘以0.8+志愿对应的gradient值乘以0.2作为每个学生的综合值，作为导师选择学生的依据，提出分层选择导师的方式。

附：
一次运行的结果
源代码

转载于:https://www.cnblogs.com/yc-chen/p/5924887.html

weixin_30945039
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于springboot+vue开发的导师学生双选系统
QQ177825331的博客
07-02 325
导师学生双选系统的背景是在高等教育领域，导师制度在培养学生方面起着重要的作用。传统的导师学生匹配通常是由学生主动选择导师，而导师是否接收学生则由导师自行决定。然而，这种方式存在一些问题，比如导师和学生之间的兴趣和研究方向不匹配、导师资源分配不均等。 为了解决这些问题，导师学生双选系统应运而生。这个系统通过建立一个在线平台，将导师和学生的信息进行搜集和匹配，然后由系统自动进行导师学生的匹配。学生可以在系统中浏览导师的个人资料、研究方向等信息，选择自己感兴趣的导师进行申请。同时，导师也可以在系统中查看学生的个
2020级计算机系软件工程第二次结对编程作业.zip
04-08
2020级计算机系软件工程第二次结对编程作业.zip 2020级计算机系软件工程第二次结对编程作业.zip 2020级计算机系软件工程第二次结对编程作业.zip 2020级计算机系软件工程第二次结对编程作业.zip 2020级计算机系软件...
毕设导师智能匹配
weixin_30730053的博客
09-30 375
结对小组：肖承志 031402327 吴宇轩 031402330 一、问题描述 编码实现一个毕设导师的智能匹配的程序。提供输入包括：30个老师（包含带学生数的要求的上限，单个数值，在[0,8]内），100个学生（包含绩点信息），每个学生有5个导师志愿（志愿的导师可以重复但不能空缺）。实现一个智能自动分配算法，根据输入信息，输出导师和学生间的匹配信息（一个学生只能有一个确认导师，一个导师可以带少...
第二次结对编程作业——毕设导师智能匹配
09-30 235
结对者：031402324 巫振格 031402338 解宇虹 一、作业的内容 编码实现一个毕设导师的智能匹配的程序。提供输入包括：30个老师（包含带学生数的要求的上限，单个数值，在[0,8]内），100个学生（包含绩点信息），每个学生有5个导师志愿（志愿的导师可以重复但不能空缺）。实现一个智能自动分配算法，根据输入信息，输出导师和学生间的匹配信息（一个学生只能有一个确认导师，一个导师...
结对编程——敏捷开发.pdf
08-22
"结对编程——敏捷开发" 结对编程（Pair Programming）是敏捷开发（Agile Development）中的一种实践方法，它是指两名开发者坐在一起，共享一台电脑，共同编写代码的过程。 结对编程的优点： 1. 提高代码质量：...
两个人的效率——记软件工程结对编程
03-04
如果你没有尝试过，那你更应该读下去，因为这篇文章将会带你体会这种编程模式，带你走进结对编程的世界。这次结对项目的名称为“学术会议的展示”，即在原有的微软学术地图的基础上，添加学术会议的信息及地理位置...
PairProgramming(结对编程)
03-02
我的第一次Pair（PairProgramming的简称，即结对编程。后面都是用Pair代替）是在ThoughtWorks公司面试进行的。那次，他们来自英国的项目经理Andy面试我，和我一起进行Pair。Andy问我以前是否Pair过，我说：“没有，...
第二次结对编程作业——毕业导师智能匹配
weixin_30699741的博客
09-30 154
结对编程人员：031402140 李严 0314026617 林瑞斌 需求分析与原型设计 问题描述 编码实现一个毕设导师的智能匹配的程序。提供输入包括：30个老师（包含带学生数的要求的上限，单个数值，在[0,8]内），100个学生（包含绩点信息），每个学生有5个导师志愿（志愿的导师可以重复但不能空缺）。实现一个智能自动分配算法，根据输入信息，输出导师和学生间的匹配信息（一个学生只能有一个确认...
毕设导师分配系统_Powerbuilder使用指导
12-27
用一个实际例子说明怎么用PowerBuilder建立窗口，嵌入SQL
教你用机器学习匹配导师 !（附代码）
weixin_40581617的博客
05-18 549
在顶点课程中我们组被分配到一个非营利机构，这个机构帮助青年学生和科技领域中的专业人士建立联系，目的在于提升在校学生对科技产业的参与度（译者注：顶点课程capstone project是美国大学高年级学生的环节，类似于中国大学的毕业设计）。学生要和导师（专业人士）配对，导师与学生会面并带他们了解这个行业。每次会面后，学生和导师都需要对会面进行评分。满分是5分，1分是最低分。这个机构根据学生的评分来衡...
Java毕业设计导师分配_结对编程作业——毕设导师智能匹配
weixin_31136061的博客
02-27 548
结对编程作业——毕设导师智能匹配031402317 李佳恺031402511 黄家俊问题描述及要求输入30个老师(包含带学生数的要求的上限，单个数值，在[0,8]内)，100个学生(包含绩点信息)，每个学生有5个导师志愿(志愿的导师可以重复但不能空缺),要求另外写生成程序随机实现实现一个智能自动分配算法，根据输入信息，输出导师和学生间的匹配信息(一个学生只能有一个确认导师，一个导师可以带少于等于其...
Java研究生导师双选系统（源码+开题）
便捷程序设计
12-25 1048
一个完善的研究生导师双选系统，不仅能够提高导师分配的效率和公平性，更能保证每一位学生都能找到最适合自己的导师，从而更好地发挥自己的潜能。从长远来看，这样的系统也有助于提高整个研究生教育的质量和水平。通过这样的系统，我们期望能够实现导师与学生之间的快速匹配，确保每位学生都能找到最适合自己的导师，同时也为学院的管理工作提供强有力的支持。2022年9月至10月：需求分析和规划，进行用户需求调研和分析，确定系统功能和目标。2023年4月至5月：文档编写和培训，编写用户手册和系统文档，并进行相关人员的培训。
【SQL笔试】1.显示的字段要有老师name, age 及每个老师所带的学生人数 2.只列出老师age为40以下学生age为12以上的记录
小帅丶的专栏
04-11 2660
偶然看到这样的SQL笔试题。数据库有3个表，teacher表 student表 teacher_student关系表 teacher表 teaID name age student表 stuID name age teacher_student表 teaID stuID 1.显示的字段要有老师name, age 及每个老师所带的学生人数 2.只列出老师age为40以下学生age为12以上的记录...
git的ssh安装,windows通过rsa生成密钥认证问题解决
demo的博客
06-13 547
点击next，进入下一步，配置下载文件以及提交文件的风格，第一个是下载使用windows风格，提交使用unix风格，第二个是下载选择文件原本样子，提交使用unix文件格式，第三个是下载是怎么杨，提交时怎么样。官网下载可能出现下载太慢的情况，Git官网下载地址为：官网，推荐官网下载，如无法下载，可移步至CSDN，csdn下载地址：https://download.csdn.net/download/m0_46309087/12428308。点击next，进入下一步，选择Git使用的终端，默认选择第一个即可。
git pull报错：unable to pull from remote repository due to conflicting tag(s)
最新发布
weixin_52047574的博客
06-17 193
我在vscode里正常拉取代码，突然就报了如题所示的错误。因为vscode的拉取按钮执行的实际命令是：git pull --tags origin branch-name，该命令的实际含义是从远程仓库拉取指定的分支和该远程仓库上的所有标签。 在拉取标签时本地的标签与远程的标签存在冲突，就报了如题所示的错误，因为git的标签时唯一的，不能有两个相同的标签指向不同的commit，所以解决方法也就出来了。
如何利用ChatGPT结对编程
04-02
ChatGPT结对编程是一种将两个程序员合作编写代码的技术。这种技术可以提高编写代码的效率和质量，同时也可以提高两位程序员的技能水平。以下是ChatGPT结对编程的步骤： 1. 首先，找到一个合适的编程伙伴。最好是一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值