完善题块，学生知识点分析

sexam/src/main/java/com/xhkjedu/sexam/service/report/EReportGenerateQuestionService.java

                 }
             }
         }
+
         List<Map> classes = examPaperClassVo.getClasses();
         // 根据试卷知识点分析进行生成学生、班级、年级知识点分析
         for (Map map : pointlist) {

smarking/src/main/java/com/xhkjedu/smarking/mapper/paper/MsPaperMapper.java

     Integer getMpIdByMsId(@Param("msid") Integer msid);
 
     //修改题块设置后试卷中试题数量
-    Integer updaePaperMeregpnumByMpid(@Param("mpid") Integer mpid, @Param("meregpnum") Integer meregpnum);
+    Integer updaePaperMeregpnumByMpid(@Param("mpid") Integer mpid, @Param("mergepnum") Integer mergepnum);
 
     //获取试卷对应科目状态
     PExamSubjectVo getSubjectStateByMpid(@Param("mpid") Integer mpid);

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectPointGroupMapper.java → smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectPointRankgroupMapper.java

 package com.xhkjedu.smarking.mapper.report.reportsubject;
 
 import com.xhkjedu.base.TkMapper;
-import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointGroup;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointRankgroup;
 
 /**
  * @Description 阅卷报告-学科知识点分段区间表 Mapper 接口
  * @Author auto
  * @Date 2024-12-09
  */
-public interface MsrSubjectPointGroupMapper extends TkMapper<MsrSubjectPointGroup> {
+public interface MsrSubjectPointRankgroupMapper extends TkMapper<MsrSubjectPointRankgroup> {
 }

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportstu/MsrStudentPoint.java

     private Integer studentid;
     //知识点ID
     private String pointid;
+    //知识点名称
+    private String pointname;
+    //知识点分数
+    private Double fullscore;
     //学生得分
     private Double stuscore;
     //学生得分率
     private Double sturate;
-    //班级平均分
-    private Double classavg;
-    //班级得分率
-    private Double classrate;
     //年级平均分
-    private Double gradeavg;
+    private Double schoolavg;
     //年级得分率
-    private Double graderate;
+    private Double schoolrate;
     //知识点对应试题题号
     private String qns;
     //知识点对应试题ID

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

     private Integer classid;
     //知识点ID
     private String pointid;
+    //知识点名称
+    private String pointname;
     //知识点级别1一级2二级3三级
     private Integer pointlevel;
     //满分
     private Double fullscore;
-    //满分人数
-    private Integer mfnum;
-    //满分人数ids
-    private String mfids;
-    //零分人数
-    private Integer lfnum;
-    //零分人数id
-    private String lfids;
     //最高分
     private Double maxscore;
     //最低分
     private Double minscore;
+    //得分率
+    private Double scorerate;
     //平均分
     private Double avgscore;
     //平均得分率%
     //区分度
     private Double qfd;
     //鉴定指数
-    private Double jdzs;
+    private Double jbzs;
     //对应试题ids
     private String mptqids;
     //对应题目

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportsubject/MsrSubjectPointGroup.java → smarking/src/main/java/com/xhkjedu/smarking/model/report/reportsubject/MsrSubjectPointRankgroup.java

  * @Date 2024-12-09
  */
 @Data
-@Table(name = "msr_subject_point_group")
-public class MsrSubjectPointGroup extends BaseBean {
+@Table(name = "msr_subject_point_rankgroup")
+public class MsrSubjectPointRankgroup extends BaseBean {
     @Id
     //阅卷报告-学科知识点排名分组
     private Integer spgid;
     private String subjectid;
     //知识点ID
     private String pointid;
+    //知识点名称
+    private String pointname;
     //知识点层级1一级2二级3三级
     private Integer pointlevel;
-    //排名分组
-    private String grouprank;
-    //分数段
-    private String scoresection;
+    //排名分组 第1组(第1~10名)
+    private String rgroup;
+    //分数段 [0-5)
+    private String rsection;
     //学生数量
     private Integer stunum;
     //学生ids

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

 
 import javax.persistence.Id;
 import javax.persistence.Table;
+import javax.persistence.Transient;
 
 /**
  * @Description 阅卷报告-学科知识点分段区间表
     private String subjectid;
     //知识点ID
     private String pointid;
+    //知识点名称
+    private String pointname;
     //知识点层级1一级2二级3三级
     private Integer pointlevel;
     //分数段范围
-    private String scoresection;
+    private String fdfw;
+    //平均分
+    private Double avgscore;
     //平均得分率
     private Double avgrate;
+
+    @Transient
+    private Integer fdnum;//分段人数
+    @Transient
+    private String fdids;//分段用户id
 }

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

     //类型1客观题选项 2客/主分值
     private Integer rgtype;
     //分值范围/选项：为空代表该组情况
-    private String rgvalue;
+    private String rsection;
     //人数
     private Integer stunum;
     //人数ids

smarking/src/main/java/com/xhkjedu/smarking/service/report/generate/ReportGeneratePointService.java

 
 import com.alibaba.fastjson.JSON;
 import com.xhkjedu.smarking.mapper.paper.MsPaperAnalyzeMapper;
+import com.xhkjedu.smarking.model.exam.MsClassStudent;
 import com.xhkjedu.smarking.model.paper.MsPaperAnalyze;
+import com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestion;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudentPoint;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPoint;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointRankgroup;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointSection;
 import com.xhkjedu.smarking.model.stupaper.MsPaperStudentQuestion;
+import com.xhkjedu.smarking.utils.MarkingUtil;
 import com.xhkjedu.smarking.vo.paper.QuestionPointVo;
+import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
+import com.xhkjedu.smarking.vo.report.reportstu.PointQuestionVo;
+import com.xhkjedu.smarking.vo.report.reportstu.PointStudentVo;
+import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * @Description：生成知识点相关分析
     @Resource
     private MsPaperAnalyzeMapper msPaperAnalyzeMapper;
 
-    public void generatePoint(List<MsPaperStudentQuestion> stuQuestions,Integer mpid) {
+    //知识点分析，题库知识点按母题分析
+    public void generatePoint(List<MsPaperStudentQuestion> stuSubjectQuestions, List<MsPaperQtypeQuestion> qtypeQuestions,List<MsClassStudent> classStus,
+                            List<MsrStudent> sturanks, Integer examid, String subjectid, Integer mpid, Double pscore) {
         //获取试卷分析
         MsPaperAnalyze paperAnalyze = msPaperAnalyzeMapper.getObjByMpId(mpid);
-        if(paperAnalyze == null) return;
+        if(paperAnalyze == null || N_Utils.isEmpty(paperAnalyze.getPointjson())) return;
 
-        QuestionPointVo qpointvo = JSON.parseObject(paperAnalyze.getPointjson(), QuestionPointVo.class);
+        List<MsrStudentPoint> saveStuPoints = new ArrayList<>();//保存学生得分情况
+        List<MsrSubjectPoint> saveSubjectPoints = new ArrayList<>();//保存科目班级知识点情况
+        List<MsrSubjectPointSection> savePointSections = new ArrayList<>();//知识点学科总分区间
+        List<MsrSubjectPointRankgroup>  savePointRankgroups = new ArrayList<>();//知识点分组
+
+        List<QuestionPointVo> qpoints = JSON.parseArray(paperAnalyze.getQuespointjson(), QuestionPointVo.class);//题号对应知识点
+        List<PointQuestionVo> pointques = JSON.parseArray(paperAnalyze.getPointjson(), PointQuestionVo.class);//知识点下题号
+
+        List<PointStudentVo> schoolStuPoints = new ArrayList<>();//每个知识点每个学生的得分
+        for (QuestionPointVo qpoint : qpoints) {
+            List<Map<String,Object>> points = qpoint.getPointids();
+            if(qpoint.getQlevel() == 1 || !N_Utils.isEmptyInteger(qpoint.getMptqid())){
+                //说明本题是单题，获取该题下所有学生的得分情况
+                List<MsPaperStudentQuestion> stuQuestions = stuSubjectQuestions.stream().filter(sq -> sq.getMptqid().equals(qpoint.getMptqid())).collect(Collectors.toList());
+                for (MsPaperStudentQuestion sq : stuQuestions) {
+                    setQuestionPointsForStuQuestion(schoolStuPoints, sq, points, qpoint.getMptqid().toString());
+                }
+            }else{
+                //说明试题为复合题，先获取所有子题
+                List<Integer> mptqids = qpoint.getMptqids();
+                String mptqidsStr = mptqids.stream().map(Object::toString).collect(Collectors.joining(","));
+                List<MsPaperStudentQuestion> stuQuestions = stuSubjectQuestions.stream().filter(sq -> mptqids.contains(sq.getMptqid())).collect(Collectors.toList());
+                //根据每个学生id，获取学生对应试题的分值
+                Map<Integer,List<MsPaperStudentQuestion>> stuQuestionMap = stuQuestions.stream().collect(Collectors.groupingBy(MsPaperStudentQuestion::getStudentid));
+                for (Map.Entry<Integer, List<MsPaperStudentQuestion>> entry : stuQuestionMap.entrySet()){
+                    List<MsPaperStudentQuestion> stuQuess = entry.getValue();
+                    Double stuScore = stuQuess.stream().mapToDouble(MsPaperStudentQuestion::getStuscore).sum();
+                    stuScore = N_Utils.formatDouble(stuScore, 1);
+                    MsPaperStudentQuestion sq = new MsPaperStudentQuestion();
+                    sq.setStudentid(entry.getKey());
+                    sq.setStuscore(stuScore);
+                    setQuestionPointsForStuQuestion(schoolStuPoints, sq, points, mptqidsStr);
+                }
+            }
+
+        }
+
+        //学科总分区间学生
+        List<MsrSubjectPointSection> pointSections = setPointSection(sturanks,pscore);
+
+        // 根据试卷知识点分析进行生成学生、年级知识点分析
+        for (PointQuestionVo pqvo : pointques){
+            List<QuestionPointVo> quePoints = pqvo.getQues();//知识点下试题
+            //获取所有试题的mptqids
+            List<Integer> mptqids = new ArrayList<>();
+            for(QuestionPointVo qpv : quePoints){
+                mptqids.addAll(qpv.getMptqids());
+            }
+            //获取试题对应的qn
+            List<MsPaperQtypeQuestion> qtypeQues =  qtypeQuestions.stream().filter(q -> mptqids.contains(q.getMptqid())).collect(Collectors.toList());
+            String qnStr = qtypeQues.stream().map(q -> q.getMptqn()  + "." + q.getQn()).collect(Collectors.joining(","));
+            String mptqidStr = mptqids.stream().map(Object::toString).collect(Collectors.joining(","));
+            // 单个知识点学生得分情况:一个知识对应一个或多个试题，
+            List<PointStudentVo> stuPoints = schoolStuPoints.stream().filter(ps -> ps.getPointid().equals(pqvo.getPointid())).collect(Collectors.toList());
+            //知识点下多个试题，处理成单个学生总分值情况
+            List<PointStudentVo> pointStuScores = new ArrayList<>();//处理成学生知识点形式，后续计算使用
+            Map<Integer, List<PointStudentVo>> pointStuMap = stuPoints.stream().collect(Collectors.groupingBy(PointStudentVo::getStudentid));
+            for (Map.Entry<Integer, List<PointStudentVo>> entry : pointStuMap.entrySet()){
+                List<PointStudentVo> pstuScores = entry.getValue();
+                Double stuScore = pstuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+                stuScore = N_Utils.formatDouble(stuScore, 1);
+                PointStudentVo firstPointStuVo = pstuScores.get(0);
+                PointStudentVo pstuvo = new PointStudentVo();
+                pstuvo.setStudentid(entry.getKey());
+                pstuvo.setPointid(firstPointStuVo.getPointid());
+                pstuvo.setStuscore(stuScore);
+                pstuvo.setScore(firstPointStuVo.getScore());
+                pointStuScores.add(pstuvo);
+            }
+
+            MsrSubjectPoint subjectPoint = new MsrSubjectPoint();
+            subjectPoint.setExamid(examid);
+            subjectPoint.setSubjectid(subjectid);
+            subjectPoint.setPointid(pqvo.getPointid());
+            subjectPoint.setClassid(0);
+            subjectPoint.setPointname(pqvo.getPointname());
+            subjectPoint.setFullscore(pqvo.getScore());
+            subjectPoint.setPointlevel(3);//3级知识点分析
+            subjectPoint.setMptqids(mptqidStr);
+            subjectPoint.setQns(qnStr);
+
+            //校知识点分析
+            MsrSubjectPoint schoolPoint = pointLevelClass(pointStuScores, subjectPoint);
+            saveSubjectPoints.add(schoolPoint);
+
+            //班级知识点分析
+            List<Integer> classIds = classStus.stream().map(MsClassStudent::getClassid).distinct().collect(Collectors.toList());
+            List<MsrSubjectPoint> classPoints = new ArrayList<>();
+            for (Integer classid : classIds) {
+                // 获取班级下学生id
+                List<Integer> classStuIds = classStus.stream().filter(c -> c.getClassid().equals(classid)).map(MsClassStudent::getStudentid).collect(Collectors.toList());
+                // 获取班级下学生试题
+                List<PointStudentVo> classStuPoints = pointStuScores.stream().filter(q -> classStuIds.contains(q.getStudentid())).collect(Collectors.toList());
+                subjectPoint.setClassid(classid);
+                MsrSubjectPoint classPoint = pointLevelClass(classStuPoints, subjectPoint);
+                classPoints.add(classPoint);
+            }
+
+            // 班级知识点保存后，要对平均分排序
+            List<Double> avgScores = classPoints.stream().map(MsrSubjectPoint::getAvgscore).collect(Collectors.toList());
+            Map<Double,Integer> avgScoreRankMap = MarkingUtil.fspm(avgScores);
+            for(MsrSubjectPoint sp : classPoints){
+                sp.setAvgrank(avgScoreRankMap.get(sp.getAvgscore()));
+            }
+            saveSubjectPoints.addAll(classPoints);
+
+            //知识点结构与总分的相关性(三级知识点)
+            List<MsrSubjectPointSection> pointSecs = pointSection(pointStuScores, pointSections, pqvo, 3);
+            savePointSections.addAll(pointSecs);
+
+            //知识点机构考生分组分析
+
+            double schoolSumScore = pointStuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+            int stunum = pointStuScores.size();
+            double schoolAvgScore = MarkingUtil.div(schoolSumScore, stunum);
+            double schoolScoreRate = MarkingUtil.calculateRate(schoolSumScore, pqvo.getScore() * stunum);
+
+            //处理学生得分情况
+            for(PointStudentVo pstuvo : pointStuScores){
+                MsrStudentPoint stuPoint = new MsrStudentPoint();
+                stuPoint.setExamid(examid);
+                stuPoint.setSubjectid(subjectid);
+                stuPoint.setStudentid(pstuvo.getStudentid());
+                stuPoint.setPointid(pqvo.getPointid());
+                stuPoint.setPointname(pqvo.getPointname());
+                stuPoint.setFullscore(pqvo.getScore());
+                stuPoint.setStuscore(pstuvo.getStuscore());
+                stuPoint.setSturate(MarkingUtil.calculateRate(pstuvo.getStuscore(), pqvo.getScore()));
+                stuPoint.setSchoolavg(schoolAvgScore);
+                stuPoint.setSchoolrate(schoolScoreRate);
+                stuPoint.setQns(qnStr);
+                stuPoint.setMptqid(mptqidStr);
+                saveStuPoints.add(stuPoint);
+            }
+        }
+
+    }
+
+    // 知识点:设置每个学生每个试题知识点得分
+    private void setQuestionPointsForStuQuestion(List<PointStudentVo> schoolStuPoints, MsPaperStudentQuestion sq, List<Map<String,Object>> points, String mptqids) {
+        if (points.size() == 1) {
+            Map<String, Object> pointmap = points.get(0);
+            // 说明该试题仅有一个知识点得分直接为改知识点分值
+            PointStudentVo pscvo = new PointStudentVo();
+            pscvo.setStudentid(sq.getStudentid());
+            pscvo.setStuscore(sq.getStuscore());
+            pscvo.setPointid(pointmap.get("pointid").toString());
+            pscvo.setMptqids(mptqids);
+            schoolStuPoints.add(pscvo);
+        } else {
+            // 计算每个知识点所占分值（平均分配）
+            Double[] avgps = N_Utils.getPointAvgScore(points.size(), sq.getStuscore());
+            for (int j = 0; j < points.size(); j++) {
+                Map<String, Object> pointmap = points.get(j);
+                PointStudentVo pscvo = new PointStudentVo();
+                pscvo.setStudentid(sq.getStudentid());
+                pscvo.setPointid(pointmap.get("pointid").toString());
+                pscvo.setMptqids(mptqids);
+                if (avgps.length == 2 && (j + 1) == points.size()) {
+                    pscvo.setStuscore(avgps[1]);
+                } else {
+                    pscvo.setStuscore(avgps[0]);
+                }
+                schoolStuPoints.add(pscvo);
+            }
+        }
+    }
+
+    //知识点分析--班级知识点
+    private MsrSubjectPoint pointLevelClass(List<PointStudentVo> pointStuScores, MsrSubjectPoint subjectPoint){
+        List<Double> stuScores = pointStuScores.stream().map(PointStudentVo::getStuscore).collect(Collectors.toList());
+        double sumScore = pointStuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+        int stuNum = pointStuScores.size();
+        double stuScoreRate = MarkingUtil.calculateRate(sumScore, pointStuScores.stream().mapToDouble(PointStudentVo::getScore).sum());
+        MsrSubjectPoint classPoint = new MsrSubjectPoint();
+        classPoint.setExamid(subjectPoint.getExamid());
+        classPoint.setSubjectid(subjectPoint.getSubjectid());
+        classPoint.setClassid(subjectPoint.getClassid());
+        classPoint.setPointlevel(subjectPoint.getPointlevel());
+        classPoint.setPointid(subjectPoint.getPointid());
+        classPoint.setPointname(subjectPoint.getPointname());
+        classPoint.setFullscore(subjectPoint.getFullscore());
+        classPoint.setMaxscore(pointStuScores.stream().mapToDouble(PointStudentVo::getStuscore).max().orElse(0.0));
+        classPoint.setMinscore(pointStuScores.stream().mapToDouble(PointStudentVo::getStuscore).min().orElse(0.0));
+        classPoint.setScorerate(MarkingUtil.calculateRate(sumScore, subjectPoint.getFullscore() * stuNum));
+        classPoint.setAvgscore(MarkingUtil.div(sumScore, stuNum));
+        classPoint.setAvgrate(MarkingUtil.calculateRate(classPoint.getAvgscore(), subjectPoint.getFullscore()));
+        classPoint.setBzc(MarkingUtil.bzc(stuScores));
+        classPoint.setCyxs(MarkingUtil.div(classPoint.getBzc(), classPoint.getAvgscore()));
+        classPoint.setQfd(MarkingUtil.qfd(stuScores));
+        classPoint.setJbzs(MarkingUtil.jbzs(stuScores, stuScoreRate));
+        classPoint.setQns(subjectPoint.getQns());
+        classPoint.setMptqids(subjectPoint.getMptqids());
+        return classPoint;
+    }
+
+    // 知识点-科目分段-默认5分一段为后续试题在段上学生得分率做准备
+    private List<MsrSubjectPointSection> setPointSection(List<MsrStudent> StuPapers, Double pscore) {
+        // 把科目总分分段，默认5分一段
+        List<RankGroupVo> fdList = MarkingUtil.fdScore(pscore, 5);
+        List<MsrSubjectPointSection> sections = new ArrayList<>();
+        MsrStudent fdStuPaper = StuPapers.get(0);
+        for (RankGroupVo fd : fdList) {
+            // 获取学生得分在指定区间的学生
+            List<MsrStudent> fdStuPapers;
+            if (fd.getMaxvalue() == pscore) {
+                fdStuPapers = StuPapers.stream().filter(s -> s.getStuscore() >= fd.getMinvalue()).collect(Collectors.toList());
+            } else {
+                fdStuPapers = StuPapers.stream().filter(s -> s.getStuscore() >= fd.getMinvalue() && s.getStuscore() < fd.getMaxvalue()).collect(Collectors.toList());
+            }
+
+            MsrSubjectPointSection question = new MsrSubjectPointSection();
+            question.setExamid(fdStuPaper.getExamid());
+            question.setSubjectid(fdStuPaper.getSubjectid());
+            question.setFdfw(fd.getGroupname());
+            question.setFdnum(fdStuPapers.size());
+            question.setFdids(fdStuPapers.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+            sections.add(question);
+        }
+        return sections;
+    }
+    //知识点-与总分分数区间相关性分析
+    private List<MsrSubjectPointSection> pointSection(List<PointStudentVo> pointStuScores,List<MsrSubjectPointSection> sections,PointQuestionVo pqvo,Integer pointlevel){
+        List<MsrSubjectPointSection> rtnList = new ArrayList<>();
+        for(MsrSubjectPointSection section : sections){
+            String[] userids = section.getFdids().split(",");
+            List<String> useridList = Arrays.asList(userids);
+            List<PointStudentVo> sectionStuPoints = pointStuScores.stream().filter(q -> useridList.contains(q.getStudentid().toString())).collect(Collectors.toList());
+            // 获取总分
+            double sumScore = sectionStuPoints.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+            int stuNum = sectionStuPoints.size();
+            // 获取平均分
+            double avgScore = MarkingUtil.div(sumScore, stuNum);
+            // 获取平均得分率
+            double avgScoreRate = MarkingUtil.calculateRate(avgScore, pqvo.getScore());
+            section.setAvgrate(avgScoreRate);
+            section.setAvgscore(avgScore);
+            section.setPointlevel(pointlevel);
+            section.setPointid(pqvo.getPointid());
+            section.setPointname(pqvo.getPointname());
+            rtnList.add(section);
+        }
+        return rtnList;
+    }
+
+    //知识点-考试排名分组分析
+    private List<MsrSubjectPointRankgroup> questionScoreRankGroup(List<PointStudentVo> pointStuScores, List<MsrStudent> stuPapers, PointQuestionVo pqvo,Integer examid,String subjectid, Integer pointlevel){
+        //获取学生排名最大名次的树
+        Integer totalRank = stuPapers.stream().mapToInt(MsrStudent::getSchoolrank).max().orElse(0);
+        //获取排名分组,默认分为7组
+        List<RankGroupVo> rankGroups = MarkingUtil.rankGroup(totalRank,7);
+        //获取知识点分段,1分1段
+        List<RankGroupVo> sectionScores = MarkingUtil.fdScore(pqvo.getScore(),5);
+
+
+        List<MsrSubjectPointRankgroup> rtnList = new ArrayList<>();
+        for (RankGroupVo rankGroup : rankGroups) {
+            //名次下学生信息
+            List<MsrStudent> groupStus = stuPapers.stream().filter(s -> s.getSchoolrank() >= rankGroup.getMinvalue() && s.getSchoolrank() <= rankGroup.getMaxvalue()).collect(Collectors.toList());
+            MsrSubjectPointRankgroup sqr = new MsrSubjectPointRankgroup();
+            sqr.setExamid(examid);
+            sqr.setSubjectid(subjectid);
+            sqr.setPointid(pqvo.getPointid());
+            sqr.setPointname(pqvo.getPointname());
+            sqr.setPointlevel(pointlevel);
+            sqr.setRgroup(rankGroup.getGroupname());
+
+            List<Integer> groupStuids;
+            List<PointStudentVo> groupStuPoints = null;
+            if(!groupStus.isEmpty()){
+                groupStuids = groupStus.stream().map(MsrStudent::getStudentid).collect(Collectors.toList());
+                //名次下学生试题作答情况
+                groupStuPoints = pointStuScores.stream().filter(q -> groupStuids.contains(q.getStudentid())).collect(Collectors.toList());
+                sqr.setStunum(groupStuPoints.size());
+                sqr.setStuids(groupStuPoints.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
+            } else {
+                groupStuids = null;
+                sqr.setStunum(0);
+            }
+
+            //试题分段区间
+            for(RankGroupVo sectionScore : sectionScores){
+                MsrSubjectPointRankgroup sqrg = new MsrSubjectPointRankgroup();
+                sqrg.setExamid(examid);
+                sqrg.setSubjectid(subjectid);
+                sqrg.setPointid(pqvo.getPointid());
+                sqrg.setPointname(pqvo.getPointname());
+                sqrg.setPointlevel(pointlevel);
+                sqrg.setRgroup(rankGroup.getGroupname());
+                sqrg.setRsection(sectionScore.getGroupname());
+
+                if(groupStuids != null && !groupStuids.isEmpty()){
+                    //名次分组下有学生，进行学生分数段计算
+                    List<PointStudentVo> sectionStuQuestions;
+                    if(sectionScore.getMinvalue() == pqvo.getScore()){
+                        //最小值为满分时分段形式为[qscore,qscore)
+                        sectionStuQuestions = groupStuPoints.stream().filter(q -> q.getStuscore() >= sectionScore.getMinvalue()).collect(Collectors.toList());
+                    }else{
+                        sectionStuQuestions = groupStuPoints.stream().filter(q -> q.getStuscore() >= sectionScore.getMinvalue() && q.getStuscore() < sectionScore.getMaxvalue()).collect(Collectors.toList());
+                    }
+                    // double sectionStuSumScore = sectionStuQuestions.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+                    // double sectionStuAvgScore = MarkingUtil.div(sectionStuSumScore, sectionStuQuestions.size());
+                    sqrg.setStunum(sectionStuQuestions.size());
+                    sqrg.setStuids(sectionStuQuestions.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
+                }else{
+                    sqrg.setStunum(0);
+                }
+
+                rtnList.add(sqrg);
+            }
+
+            rtnList.add(sqr);
+        }
+        return rtnList;
     }
 }

smarking/src/main/java/com/xhkjedu/smarking/service/report/generate/ReportGenerateQuestionService.java

                 sqrg.setMptqid(mptqid);
                 sqrg.setRgroup(rankGroup.getGroupname());
                 sqrg.setRgtype(2);
-                sqrg.setRgvalue(sectionScore.getSectionname());
+                sqrg.setRsection(sectionScore.getSectionname());
 
                 if(groupStuids != null && !groupStuids.isEmpty()){
                     //名次分组下有学生，进行学生分数段计算
                     optionObj.setQntype(1);
                     optionObj.setRgroup(rankGroup.getGroupname());
                     optionObj.setRgtype(1);
-                    optionObj.setRgvalue(optionStr);
+                    optionObj.setRsection(optionStr);
 
                     List<MsPaperStudentQuestion> optionStuQuestions;
                     if(groupStuQuestions != null && !groupStuQuestions.isEmpty()){
             // 获取学生得分在指定区间的学生
             List<MsrStudent> fdStuPapers;
             if (fd.getMaxvalue() == pscore) {
-                fdStuPapers = StuPapers.stream().filter(s -> s.getStuscore() >= fd.getMinvalue() && s.getStuscore() <= fd.getMaxvalue()).collect(Collectors.toList());
+                fdStuPapers = StuPapers.stream().filter(s -> s.getStuscore() >= fd.getMinvalue()).collect(Collectors.toList());
             } else {
                 fdStuPapers = StuPapers.stream().filter(s -> s.getStuscore() >= fd.getMinvalue() && s.getStuscore() < fd.getMaxvalue()).collect(Collectors.toList());
             }
         return sections;
     }
 
-    // 单个试题分析-科目分段区间得分率
+    // 单个试题分析-科目分段区间平均得分率
     private List<MsrSubjectQuestionSection> subjectSectionQuestion(List<MsPaperStudentQuestion> stuQuestions, List<MsrSubjectQuestionSection> sections,
                             Integer qtype,Double fullScore,Integer mptqid) {
         List<MsrSubjectQuestionSection> rtnList = new ArrayList<>();

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

         if (N_Utils.isListEmpty(list)) return modes;
 
         // 使用HashMap来统计每个元素出现的次数
-        Map<Double, Long> countMap = list.stream()
-                                         .collect(Collectors.groupingBy(e -> e, Collectors.counting()));
+        Map<Double, Long> countMap = list.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
 
         long maxCount = 0;
         // 找出最大的出现次数

smarking/src/main/java/com/xhkjedu/smarking/vo/report/reportstu/PointQuestionVo.java

+package com.xhkjedu.smarking.vo.report.reportstu;
+
+import com.xhkjedu.smarking.vo.paper.QuestionPointVo;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Description：知识点下试题
+ * @Author: WN
+ * @Date: 2024/12/17 9:51:04
+ **/
+@Data
+public class PointQuestionVo {
+
+    private String pointid;//知识点id
+
+    private String pointname;//知识点名称
+
+    private Double score;//知识点分数
+
+    private Double srate;//知识点试卷占比
+
+    private List<QuestionPointVo> ques;//知识点包含试题
+}

smarking/src/main/java/com/xhkjedu/smarking/vo/report/reportstu/PointStudentVo.java

+package com.xhkjedu.smarking.vo.report.reportstu;
+
+import lombok.Data;
+
+/**
+ * @Description：学生知识点
+ * @Author: WN
+ * @Date: 2024/12/16 17:49:01
+ **/
+@Data
+public class PointStudentVo {
+    private Integer studentid;//学生id
+
+    private String pointid;//知识点id
+
+    private Double score;//试题分值
+
+    private Double stuscore;//学生得分
+
+    private String mptqids;//试题id
+}

smarking/src/main/resources/mapper/paper/MsPaperMapper.xml

 
     <!--获取试卷ID及考试模式-->
     <select id="getPaperAndMxammodeByMsid" resultType="com.xhkjedu.smarking.vo.paper.PExamSubjectVo">
-        select p.mpid,e.exammode from ms_paper p left join ms_exam e on p.examid=e.examidwhere p.msid=#{msid}
+        select p.mpid,e.exammode from ms_paper p left join ms_exam e on p.examid=e.examid where p.msid=#{msid}
     </select>
     <!--根据考试id和科目id获取试卷信息-->
     <select id="getPaperByExamIdAndSubjectId" resultType="com.xhkjedu.smarking.model.paper.MsPaper">

smarking/src/main/resources/mapper/paper/MsPaperQtypeQuestionMapper.xml

 
     <!--试卷中所有试题-考试报告-->
     <select id="listQuestionsForReport" resultType="com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestion">
-        select q.mptqid,q.mptid,q.mpid,q.ctype,q.qtype,q.questionid,q.qtypeid,q.qtypename,q.qn,
+        select q.mptqid,q.mptid,q.mpid,q.ctype,q.qtype,q.questionid,q.qtypeid,q.qtypename,q.qn,q.questionid,q.questionpid,
         q.qscore,q.qorder,q.optionnum,q.qanswer,qt.mptqn,qt.mptnum,qt.mptscore
         from ms_paper_qtype_question q left join ms_paper_qtype qt on q.mptid=qt.mptid
         where q.mpid=#{mpid} order by qt.mptorder,q.qorder

smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectPointGroupMapper.xml → smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectPointRankgroupMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointGroupMapper">
+<mapper namespace="com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointRankgroupMapper">
 </mapper>