学科、学生成绩分析

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportsubject/MsrSubject.java

     private Double minscore;
     //平均分
     private Double avgscore;
-    //平均成绩排名率
+    //平均成绩排名
     private Integer avgrank;
+    //平均成绩排名率
+    private Double avgrankrate;
     //得分率
     private Double scorerate;
     //总人数

smarking/src/main/java/com/xhkjedu/smarking/service/report/reportother/MsrExamService.java

 
 import com.xhkjedu.smarking.mapper.exam.*;
 import com.xhkjedu.smarking.mapper.report.reportother.MsrExamMapper;
+import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectMapper;
 import com.xhkjedu.smarking.mapper.stupaper.MsPaperStudentMapper;
 import com.xhkjedu.smarking.model.exam.*;
 import com.xhkjedu.smarking.model.paper.MsPaper;
 import com.xhkjedu.smarking.model.report.reportother.MsrExam;
 import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
-import com.xhkjedu.smarking.model.stupaper.MsPaperStudent;
 import com.xhkjedu.smarking.utils.MarkingUtil;
 import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
     private MsClassStudentMapper classStudentMapper;
     @Resource
     private MsPaperStudentMapper paperStudentMapper;
+    @Resource
+    private MsrSubjectMapper msrSubjectMapper;
+    @Resource
+    private MsrStudentMapper msrStudentMapper;
 
     /**
      * @Description 生成报告
         List<MsClass> classes = classMapper.listClassByExamId(examid);//获取考试关联班级
         List<MsClassStudent> students = classStudentMapper.listStudentByExamId(examid);//获取考试关联学生
         List<Integer> mpids = new ArrayList<>();
-        Map<String, Double> paperScoreMap = new HashMap<>();
         for (MsPaper subject : subjects) {
             Integer mpid = subject.getMpid();
             mpids.add(mpid);
-            paperScoreMap.put(subject.getSubjectid(), subject.getPscore());
         }
         List<MsrStudent> paperStudents = paperStudentMapper.listPaperStudentByExamId(examid, mpids);//试学生成绩列表
         for (MsrStudent student : paperStudents) {
-            student.setScorerate(N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), paperScoreMap.get(student.getSubjectid())));
+            student.setScorerate(N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), student.getFullscore()));
         }
 
         Integer classnum = N_Utils.obj2Int(classes.stream().map(MsClass::getClassid).distinct().count());
         Integer missnum = totalnum - stunum;
         double fullscore = subjects.stream().mapToDouble(MsPaper::getPscore).sum();
         List<MsrStudent> schoolStudents = new ArrayList<>();//学校学生成绩
-        List<MsrStudent> schoolSubjectStudents = new ArrayList<>();//学校科目学生成绩
-        List<MsrStudent> classStudents = new ArrayList<>();//班级学生成绩
+        List<MsrStudent> classStudents = new ArrayList<>();//班级学生成绩(总分)
         List<MsrStudent> classSubjectStudents = new ArrayList<>();//班级科目学生成绩
         Map<String, Integer> schoolStuRank = new HashMap<>();//学校学生分数排名
         Map<String, Integer> schoolSubStuRank = new HashMap<>();//学校科目学生分数排名
             }
         }
         String subjectid;
+        Map<String, Double> bjdfMap = new HashMap<>();//班级得分
         Map<Integer, List<MsrStudent>> cCollect = paperStudents2.stream().collect(Collectors.groupingBy(MsrStudent::getClassid));
         for (Map.Entry<Integer, List<MsrStudent>> entry : cCollect.entrySet()) {
             Integer classid = entry.getKey();
                 cs.setStuscore(csEntry.getValue().stream().mapToDouble(MsrStudent::getStuscore).sum());
                 rstudents.add(cs);
             }
+            bjdfMap.put(classid + "_" + subjectid, rstudents.stream().mapToDouble(MsrStudent::getStuscore).sum());
             setRank(rstudents, classStuRank, 3);//班级学生分数排名
             classStudents.addAll(rstudents);
             Map<String, List<MsrStudent>> subCollect = studentList.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid));
             for (Map.Entry<String, List<MsrStudent>> ssEntry : subCollect.entrySet()) {
+                subjectid = ssEntry.getKey();
                 rstudents = ssEntry.getValue();
+                bjdfMap.put(classid + "_" + subjectid, rstudents.stream().mapToDouble(MsrStudent::getStuscore).sum());
                 setRank(rstudents, classSubStuRank, 4);//班级科目学生分数排名
                 classSubjectStudents.addAll(rstudents);
             }
         }
+        setRank(schoolStudents, schoolStuRank, 1);//学校学生分数排名
 
         List<MsrStudent> schoolStudents2 = schoolStudents.stream().filter(s -> s.getSstate().equals(2)).collect(Collectors.toList());//参与统计学生列表
         DoubleSummaryStatistics schoolStatistics = schoolStudents2.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics();
         msrExamMapper.insert(msrExam);
 
         //科目分析
+        Map<String, MsrSubject> subjectMap = new HashMap<>();//科目分析map
         Map<String, List<MsrStudent>> subjectCollect = paperStudents.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid));
         List<MsrSubject> msrSubjects = new ArrayList<>();
         MsrSubject msrSubject = new MsrSubject();
         msrSubject.setExamid(examid);
-        msrSubject.setSubjectid("zf");
+        subjectid = "zf";
+        msrSubject.setSubjectid(subjectid);
         msrSubject.setSubjectname("总分");
         msrSubject.setFullscore(fullscore);
         msrSubject.setMaxscore(schoolStatisticsMax);
         msrSubject.setMinscore(schoolStatisticsMin);
         msrSubject.setAvgscore(schoolStatisticsAverage);
-        msrSubject.setScorerate(N_Utils.getDoubleDivideAndMulitiply(schoolStatisticsAverage, fullscore));
-        List<Double> scores = schoolStudents2.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
-        double bzc = MarkingUtil.bzc(scores);
-        msrSubject.setBzc(bzc);
-        msrSubject.setCyxs(N_Utils.getDoubleDivideAndMulitiply(bzc, schoolStatisticsAverage));
-        msrSubject.setNd(MarkingUtil.div(schoolStatisticsAverage, fullscore));
-        msrSubject.setQfd(MarkingUtil.qfd(scores));
-        List<Double> scoreRates = schoolStudents2.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
-        double dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
-        msrSubject.setDfllc(dfllc);
-        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, schoolStatisticsAverage));
-        msrSubject.setEsscore(MarkingUtil.cynjdf(scores, 0.2));
-        msrSubject.setSsscore(MarkingUtil.cynjdf(scores, 0.4));
-        msrSubject.setLsscore(MarkingUtil.cynjdf(scores, 0.6));
-        msrSubject.setBsscore(MarkingUtil.cynjdf(scores, 0.8));
         msrSubject.setTotalnum(totalnum);
         msrSubject.setStunum(stunum);
         msrSubject.setMissnum(missnum);
+        setSubject(msrSubject, schoolStudents2);
         msrSubjects.add(msrSubject);
+        subjectMap.put(subjectid, msrSubject);
         for (MsPaper subject : subjects) {
+            subjectid = subject.getSubjectid();
             msrSubject = new MsrSubject();
             msrSubject.setExamid(examid);
-            msrSubject.setSubjectid(subject.getSubjectid());
+            msrSubject.setSubjectid(subjectid);
             msrSubject.setSubjectname(subject.getSubjectname());
             msrSubject.setFullscore(subject.getPscore());
-            List<MsrStudent> studentList = subjectCollect.get(subject.getSubjectid());
+            List<MsrStudent> studentList = subjectCollect.get(subjectid);
+            setRank(studentList, schoolSubStuRank, 2);//学校科目学生分数排名
             List<MsrStudent> studentList2 = studentList.stream().filter(s -> s.getSstate().equals(2)).collect(Collectors.toList());//参与统计学生列表
             totalnum = studentList.size();
             stunum = studentList2.size();
             msrSubject.setMaxscore(subjectStatisticsMax);
             msrSubject.setMinscore(subjectStatisticsMin);
             msrSubject.setAvgscore(subjectStatisticsAverage);
-            msrSubject.setScorerate(N_Utils.getDoubleDivideAndMulitiply(subjectStatisticsAverage, fullscore));
-            scores = studentList2.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
-            bzc = MarkingUtil.bzc(scores);
-            msrSubject.setBzc(bzc);
-            msrSubject.setCyxs(N_Utils.getDoubleDivideAndMulitiply(bzc, subjectStatisticsAverage));
-            msrSubject.setNd(MarkingUtil.div(subjectStatisticsAverage, fullscore));
-            msrSubject.setQfd(MarkingUtil.qfd(scores));
-            scoreRates = studentList2.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
-            dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
-            msrSubject.setDfllc(dfllc);
-            msrSubject.setDflxdlc(MarkingUtil.div(dfllc, subjectStatisticsAverage));
-            msrSubject.setEsscore(MarkingUtil.cynjdf(scores, 0.2));
-            msrSubject.setSsscore(MarkingUtil.cynjdf(scores, 0.4));
-            msrSubject.setLsscore(MarkingUtil.cynjdf(scores, 0.6));
-            msrSubject.setBsscore(MarkingUtil.cynjdf(scores, 0.8));
+            setSubject(msrSubject, studentList2);
             msrSubjects.add(msrSubject);
+            subjectMap.put(subjectid, msrSubject);
+        }
+        List<Double> avgScores = msrSubjects.stream().map(MsrSubject::getAvgscore).sorted().collect(Collectors.toList());
+        Map<Double, Integer> fspm = MarkingUtil.fspm(avgScores);//平均分排名
+        for (MsrSubject subject : msrSubjects) {
+            subject.setAvgrank(fspm.get(subject.getAvgscore()));
+            subject.setAvgrankrate(MarkingUtil.div(subject.getAvgrank(), subject.getTotalnum()));
+        }
+        msrSubjectMapper.insertList(msrSubjects);
+
+        //学生成绩分析
+        for (MsrStudent student : classStudents) {
+            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap);
+        }
+        for (MsrStudent student : classSubjectStudents) {
+            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap);
         }
+        if (N_Utils.isListNotEmpty(classStudents)) msrStudentMapper.insertList(classStudents);
+        if (N_Utils.isListNotEmpty(classSubjectStudents)) msrStudentMapper.insertList(classSubjectStudents);
 
         examMapper.updateExamState(examid, 3);
     }
 
+    //设置科目分析计算参数
+    private void setSubject(MsrSubject msrSubject, List<MsrStudent> schoolStudents2) {
+        Double avgscore = msrSubject.getAvgscore();
+        Double fullscore = msrSubject.getFullscore();
+        msrSubject.setScorerate(N_Utils.getDoubleDivideAndMulitiply(avgscore, fullscore));
+        List<Double> scores = schoolStudents2.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
+        double bzc = MarkingUtil.bzc(scores);
+        msrSubject.setBzc(bzc);
+        msrSubject.setCyxs(N_Utils.getDoubleDivideAndMulitiply(bzc, avgscore));
+        msrSubject.setNd(MarkingUtil.div(avgscore, fullscore));
+        msrSubject.setQfd(MarkingUtil.qfd(scores));
+        List<Double> scoreRates = schoolStudents2.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
+        double dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
+        msrSubject.setDfllc(dfllc);
+        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, avgscore));
+        msrSubject.setEsscore(MarkingUtil.cynjdf(scores, 0.2));
+        msrSubject.setSsscore(MarkingUtil.cynjdf(scores, 0.4));
+        msrSubject.setLsscore(MarkingUtil.cynjdf(scores, 0.6));
+        msrSubject.setBsscore(MarkingUtil.cynjdf(scores, 0.8));
+    }
+
+    //设置学生分析计算参数
+    private void setStudent(MsrStudent student, Map<String, Integer> classStuRank, Map<String, Integer> schoolStuRank
+            , Map<String, Integer> classSubStuRank, Map<String, Integer> schoolSubStuRank
+            , Map<String, Double> bjdfMap, Map<String, MsrSubject> subjectMap) {
+        String subjectid;
+        Integer classid = student.getClassid();
+        Integer studentid = student.getStudentid();
+        subjectid = student.getSubjectid();
+        MsrSubject msrSubject = subjectMap.get(subjectid);
+        Double pjf = msrSubject.getAvgscore();//年级平均分
+        student.setBzf(MarkingUtil.bzf(bjdfMap.get(classid + "_" + subjectid), pjf, msrSubject.getBzc()));
+        Integer classrank;
+        Integer schoolrank;
+        if (subjectid.equals("zf")) {
+            classrank = classStuRank.get(classid + "_" + studentid);
+            schoolrank = schoolStuRank.get(studentid.toString());
+        } else {
+            classrank = classSubStuRank.get(classid + "_" + subjectid + "_" + studentid);
+            schoolrank = schoolSubStuRank.get(subjectid + "_" + studentid);
+        }
+        student.setCjl(MarkingUtil.cjl(student.getStuscore(), pjf));
+        student.setClassrank(classrank);
+        student.setSchoolrank(schoolrank);
+        double rankrate = MarkingUtil.div(schoolrank, msrSubject.getTotalnum());
+        student.setRankrate(rankrate);//个人成绩排名率=自己所在学科成绩分数的名次/总人数
+        student.setXkqrz(MarkingUtil.sub(msrSubject.getAvgrank(), rankrate));//学科强弱值 = 平均成绩排名率- 个人成绩排名率
+    }
+
     //分数排名
     private void setRank(List<MsrStudent> students, Map<String, Integer> rank, Integer code) {
         List<Map.Entry<Double, List<MsrStudent>>> gslist2 = students.stream()

smarking/src/main/java/com/xhkjedu/smarking/utils/MarkingUtil.java

         return scores.get(totalCount - topCount);
     }
 
+    //分数排名
+    public static Map<Double,Integer> fspm(List<Double> scores) {
+        // 创建一个地图来存储分数和出现次数
+        Map<Double, Integer> scoreCountMap = new HashMap<>();
+
+        // 遍历 scores 计算分数出现的次数
+        for (Double score : scores) {
+            scoreCountMap.put(score, scoreCountMap.getOrDefault(score, 0) + 1);
+        }
+        return scoreCountMap;
+    }
+
 }

smarking/src/main/resources/mapper/exam/MsSubjectMapper.xml

     <select id="listReportSubject" resultType="com.xhkjedu.smarking.model.paper.MsPaper">
         select s.subjectid,s.subjectname,p.mpid,p.pnum,p.mergepnum,p.pscore,p.correcttype
         from ms_subject s inner join ms_paper p on s.msid=p.msid
-        where s.examid=#{examid}
+        where s.examid=#{examid} and s.msid=2
         <if test="exammode!=3">
             and s.msstate=2
         </if>

smarking/src/main/resources/mapper/stupaper/MsPaperStudentMapper.xml

     </select>
     <!--考试学生成绩列表-->
     <select id="listPaperStudentByExamId" resultType="com.xhkjedu.smarking.model.report.reportstu.MsrStudent">
-        select mpid,subjectid,studentid,stuscore
+        select mpid,subjectid,studentid,stuscore,sstate,pscore as fullscore
         from ms_paper_student where examid=#{examid}
-        <foreach collection="mpids" item="mpid" separator="and mpid in (">
+        <foreach collection="mpids" item="mpid" open="and mpid in (" separator="," close=")">
             #{mpid}
         </foreach>
     </select>