• PTA训练集总结blog
  • 1.前言
  • 2.设计与分析
    • 题目集一 7.4 答题判题程序四
      • 关于设计要求：
      • UML类图及设计分析：
      • 部分源码：
      • 复杂度分析：
    • 题目集五 7.1 家具强电电路模拟系统—1
      • 关于设计要求：
      • UML类图及设计分析：
      • 部分源码：
      • 复杂度分析：
    • 题目集六 家居强电电路模拟程序-2
      • 关于设计要求：
      • UML类图及设计分析：
      • 部分源码：
      • 复杂度分析：
  • 3.踩坑心得
  • 4.改进建议
  • 5.总结

PTA训练集总结blog

1.前言

1.这次是4-6次的pta作业的一个总结性blog。
答题程序在第四次迭代之后已功成身退。但已经没有时间怀念答题程序了，紧接着登场的是家居强电电路模拟程序系列。目前这个系列已经迭代两次，我个人感觉这个系列比前面的答题程序要难。前言无力，请移步正文。

2.设计与分析

题目集一 7.4 答题判题程序四

关于设计要求：

设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。 这次的答题程序加上了多选和填空题，在想了一个下午之后， 得出多选保存答案，填空equals比较的可实现方法（想到的一些其他方法我不会实现很尴尬。）

UML类图及设计分析：

emm…类图还是比较复杂的，但是说实话主要的判定逻辑还是放在了Main类的processAnswers类里，不过是比上次多了一个“抽象父类—子类”的结构来实现多种题型的设计。

部分源码：

public void processAnswers() {
        int y = 0;
        for (TestPaper tp : testPapers) {
            if (tp.getallscore() != 100) {
                System.out.println("alert: full score of test paper" + tp.getPaperNumber() + " is not 100 points");
            }
        }
    
        //判断是否被删除，此处省略。。。
    
        if(!answerSheets.isEmpty()) {
            //对答卷排序
            for(int i=0;i<answerSheets.size()-1;i++){
             for(int j=0;j<answerSheets.size()-1-i;j++){
                 if(answerSheets.get(j).getStudentNumber()> answerSheets.get(j + 1).getStudentNumber())					{
                 AnswerSheet temp= answerSheets.get(j);
                 answerSheets.set(j, answerSheets.get(j + 1));
                 answerSheets.set(j + 1, temp);
                 }
                 if(answerSheets.get(j).getStudentNumber()== answerSheets.get(j +1).getStudentNumber())					{
                     if(answerSheets.get(j).getPaperNumber()> answerSheets.get(j + 1).getPaperNumber())						{
                       AnswerSheet temp= answerSheets.get(j);
                       answerSheets.set(j, answerSheets.get(j + 1));
                       answerSheets.set(j + 1, temp);
                     }
                 }
                }
             }
            for (AnswerSheet answerSheet : answerSheets) {
               List<Integer> score = new LinkedList<>();
               int totalScore = 0;
               int questionScore;
               List<Integer> answernums = answerSheet.getAnswernums();
                TestPaper testPaper = null;
                for (TestPaper t : testPapers) {
                    if (t.getPaperNumber() == answerSheet.getPaperNumber()) {
                        testPaper = t;
                        break;
                    }
                }
                int c = 0;
                if (testPaper != null) {
                    for (int j = 0; j < testPaper.getQuestionNums().size(); j++) {
                        int t = 0;
                        for (int k = 0; k < answernums.size(); k++) {
                            if (answernums.get(k) == j + 1) {
                                t = 1;
                                c = k;
                                break;
                            }
                        }
                        if (t != 0) {
                            String answer = answerSheet.getAnswers().get(answernums.get(c));
                            String answer1 = answerSheet.getAnswers().get(answernums.get(c));
                            int questionNumber = testPaper.getQuestionNums().get(j);
                            Question question = null;
                            selectQuestion selectquestion = null;
                            blankQuestion blankquestion = null;
                            for (Question q : questions) {
                                if (q.getNumber() == questionNumber) {
                                    question = q;
                                    break;
                                }
                            }
                            for (selectQuestion q : selectquestions) {
                                if (q.getNumber() == questionNumber) {
                                    selectquestion = q;
                                    break;
                                }
                            }
                            for (blankQuestion q : blankquestions) {
                                if (q.getNumber() == questionNumber) {
                                    blankquestion = q;
                                    break;
                                }
                            }
                            if (question != null) {
                                if (question.flag == 0) {
                                    if (question.judge(answer)==Result.True) {
                                        questionScore = testPaper.getQuestions().get(questionNumber);
                                        totalScore += questionScore;
                                        System.out.println(question.getContent() + "~" + answer + "~true");
                                        score.add(questionScore);
                                    } else {
                                        System.out.println(question.getContent() + "~" + answer + "~false");
                                        score.add(0);
                                    }
                                }
                                else {
                                    System.out.println("the question " + question.getNumber() + " invalid~0");
                                    score.add(0);
                                }
                            }
                            else if(selectquestion != null){
                                if (selectquestion.flag == 0) {
                                    if (selectquestion.judge(answer)==Result.True) {
                                        questionScore = testPaper.getQuestions().get(questionNumber);
                                        totalScore += questionScore;
                                        System.out.println(selectquestion.getContent() + "~" + answer + "~true");
                                     score.add(questionScore);
                                    }
                                    else if(selectquestion.judge(answer)==Result.partiallycorrect){
                                        System.out.println(selectquestion.getContent() + "~" + answer + "~partially correct");
                                        questionScore = testPaper.getQuestions().get(questionNumber);
                                        totalScore += questionScore;
                                        totalScore=totalScore/2;
                                        score.add(questionScore/2);
                                    }
                                    else {
                     System.out.println(selectquestion.getContent() + "~" + answer + "~false");
                                        score.add(0);
                                    }
                                }
                                else {
                                    System.out.println("the question " + selectquestion.getNumber() + " invalid~0");
                                    score.add(0);
                                }
                            }
                            else if(blankquestion != null){
                                if (blankquestion.flag == 0) {
                                    if (blankquestion.judge(answer)==Result.True) {
                                        questionScore = testPaper.getQuestions().get(questionNumber);
                                        totalScore += questionScore;
                                        System.out.println(blankquestion.getContent() + "~" + answer1 + "~true");
                                        score.add(questionScore);
                                    }
                                    else if(blankquestion.judge(answer)==Result.partiallycorrect){
                                        System.out.println(blankquestion.getContent() + "~" + answer1 + "~partially correct");
                                        questionScore = testPaper.getQuestions().get(questionNumber);
                                        totalScore += questionScore;
                                        totalScore=totalScore/2;
                                        score.add(questionScore/2);
                                    }
                                    else {
                                        System.out.println(blankquestion.getContent() + "~" + answer1 + "~false");
                                        score.add(0);
                                    }
                                }
                                else {
                                    System.out.println("the question " + blankquestion.getNumber() + " invalid~0");
                                    score.add(0);
                                }
                            }
                            else {
                                System.out.println("non-existent question~0");
                                score.add(0);
                            }
                        } else {
                            System.out.println("answer is null");
                            score.add(0);
                        }
                    }
                    answerSheet.setTotalScore(totalScore);
                    int studentnum = 0;  //添加学号审查
                    for (int num : students.getStudentNums()) {
                        if (num == answerSheet.getStudentNumber()) {
                            studentnum = num;
                        }
                    }
                    if (studentnum != 0) {
                        System.out.print(studentnum + " " + students.getStudents().get(studentnum) + ": ");
                        for (int j = 0; j < score.size(); j++) {
                            Integer i = score.get(j);
                            System.out.printf("%d", i);
                            if (j < score.size() - 1) {
                                System.out.printf(" ");
                            }
                        }
                        System.out.printf("~%d", answerSheet.getTotalScore());
                        if (y < answerSheets.size() - 1) {
                            System.out.println();
                        }
                    } else {
                        System.out.println(answerSheet.getStudentNumber() + " not found");
                    }
                } else {
                    System.out.println("The test paper number does not exist");
                }
            }
        }
        else{
            for(int i=0;i<b;i++){
                System.out.println("The test paper number does not exist");
            }
        }
    }

复杂度分析：

题目集五 7.1 家具强电电路模拟系统—1

关于设计要求：

1、控制设备模拟

本题模拟的控制设备包括：开关、分档调速器、连续调速器。

2、受控设备模拟

本题模拟的受控设备包括：白炽灯、日光灯，风扇。三种设备都有两根引脚，通过两根引脚电压的电压差驱动设备工作。

本题不考虑输入电压或电压差超过220V的情况。

本题只考虑串联的形式，所以所有测试用例的所有连接信息都只包含两个引脚

本题电路中除了开关可能出现多个，其他电路设备均只出现一次。
电源VCC一定是第一个连接的第一项，接地GND一定是最后一个连接的后一项。

家居电路模拟系列所有题目的默认规则：

1、当计算电压值等数值的过程中，最终结果出现小数时，用截尾规则去掉小数部分，只保留整数部分。为避免精度的误差，所有有可能出现小数的数值用double类型保存并计算，不要作下转型数据类型转换，例如电压、转速、亮度等，只有在最后输出时再把计算结果按截尾规则，舍弃尾数，保留整数输出。

2、所有连接信息按电路从电源到接地的顺序依次输入，不会出现错位的情况。

3、连接信息如果只包含两个引脚，靠电源端的引脚在前，靠接地端的在后。

4、对于调速器，其输入端只会直连VCC，不会接其他设备。整个电路中最多只有一个调速器，且连接在电源上。

UML类图及设计分析：

这次的题目集说实话还好，只是多个电器的问题，学会继承多态的我也是拿下，因为只有串联，所以我只设计了串联的电压计算，并没有做串联电路类。还是把计算放在了Main类valid方法里,虽然当时有种不好的预感，但是还是这样设计了。并且因为不想给每个类对象一个名称属性，所以用的LinkedHashmap。这也在下次的迭代中给我不小的麻烦，当然，这是后话了。

部分源码：

public void valid() {
        int Flag=0;
        List<String> Key = new ArrayList<>();
        List<Device> arr = new ArrayList<>();
        Map<String, Device> devices = new HashMap<>();
        for (String key : series.keySet()) {
            arr.add(series.get(key));
            Key.add(key);
        }

        for (int i = 0; i < arr.size(); i++) {
            Device dev = arr.get(i);
            if (dev instanceof Switch) {
                if (((Switch) dev).getState()==0){
                    Flag=1;
                    break;
                }
            }
        }
        if (Flag==0) {
            arr.get(0).input = 220;
            for (int i = 1; i < arr.size(); i++) {
                Device dev = arr.get(i - 1);
                if (dev instanceof controlEquip) {
                    arr.get(i).input = ((controlEquip) dev).getOutput();
                }
                if (dev instanceof controlledEquip) {
                    arr.get(i).input = dev.input;
                }
            }
        }

        for (int i = 0; i < arr.size(); i++) {
            devices.put(Key.get(i), arr.get(i));
        }

        for (String key : devices.keySet()) {
            if (devices.get(key) instanceof Switch) {
                Switch sw = (Switch) devices.get(key);
                System.out.println("@" + key + ":" + (sw.getState() == 1 ? "closed" : "turned on"));
            }
        }
        for (String key : devices.keySet()) {
            if (devices.get(key) instanceof GearSpeedController) {
                GearSpeedController gear = (GearSpeedController) devices.get(key);
                System.out.println("@" + key + ":" + gear.getGear());
            }
        }
        for (String key : devices.keySet()) {
            if (devices.get(key) instanceof ContinuousSpeedController) {
                ContinuousSpeedController cont = (ContinuousSpeedController) devices.get(key);
                System.out.println("@" + key + ":" + String.format("%.2f", cont.getPosition()));
            }
        }
        for (String key : devices.keySet()) {
            if (devices.get(key) instanceof LightBulb) {
                LightBulb lightbulb = (LightBulb) devices.get(key);
                lightbulb.setBrightness();
                System.out.println("@" + key + ":" + (int)lightbulb.getBrightness());
            }
        }
        for (String key : devices.keySet()) {
            if (devices.get(key) instanceof FluorescentLamp) {
                FluorescentLamp fluor = (FluorescentLamp) devices.get(key);
                fluor.setBrightness();
                System.out.println("@" + key + ":" + (int)fluor.getBrightness());
            }
        }
        for (String key : devices.keySet()) {
            if (devices.get(key) instanceof Fan) {
                Fan fan = (Fan) devices.get(key);
                fan.setSpeed();
                System.out.println("@" + key + ":" + (int)fan.getSpeed());
            }
        }
    }

复杂度分析：

题目集六 家居强电电路模拟程序-2

关于设计要求：

这次的程序加入了并联的情况，这使我不得不重新设计代码分类并联串联两种电压计算模版。

加入一个新的落地扇类，倒是不难。

还有以下对于并联串联的新要求：

输入信息以end为结束标志，忽略end之后的输入信息。

本题中的并联信息所包含的串联电路的信息都在并联信息之前输入，不考虑乱序输入的情况。
电路中的短路如果不会在电路中产生无穷大的电流烧坏电路，都是合理情况，在本题测试点的考虑范围之内。

本题不考虑一条串联电路中包含其他串联电路的情况。

UML类图及设计分析：

这次因为重新设计，有些仓促，舍弃了Map改为List。判断逻辑和电压赋值也是在Main类里完成的，类间关系有点复杂。

真的是狠狠吃了设计不好的亏。电压赋值做的也不够完善。

部分源码：

 public void valid() {

        //得出电流
        double A = (220/this.resistance);
        //将map转为两个list

            //判断是否短路
            for (Device Dev:series){
                if (!(Dev instanceof Switch)) {
                    flags = 0;
                    break;
                }
            }
            //判断是否断路,返Flag值
            for (Device dev:series) {
                if (dev instanceof Switch) {
                    if (((Switch) dev).getState()==0){
                        Flag=1;
                        break;
                    }
                }
            }
        //总串联赋电压值
        if (Flag==0) {
            series.get(0).input = 220;
            for (int i = 1; i < series.size(); i++) {
                Device dev = series.get(i - 1);
                if (dev instanceof controlEquip) {
                    series.get(i).input = ((controlEquip) dev).getOutput();
                    A=(series.get(i).input/ dev.input)*A;
                }
                    if (series.get(i) instanceof Fan) {
                        series.get(i).input =A*Fan.resistance;
                    }
                    if (series.get(i) instanceof gFan) {
                        series.get(i).input =A*gFan.resistance;
                    }
                    if (series.get(i) instanceof LightBulb) {
                        series.get(i).input =A*LightBulb.resistance;
                    }
                    if (series.get(i) instanceof DaylightLamp) {
                        series.get(i).input =A*DaylightLamp.resistance;
                    }
                    if (series.get(i) instanceof Series) {
                        for(Series se:Main.series_es){
                            if(((Series) series.get(i)).name.equals(se.name)) {
                                series.get(i).input =A*se.getResistance();
                            }
                        }
                    }
                    if (series.get(i) instanceof Parallel) {
                        for(Parallel pa:Main.parallel_es){
                            if(((Parallel) series.get(i)).name.equals(pa.name)) {
                                series.get(i).input =A*pa.getResistance();
                                ((Parallel) series.get(i)).out();
                            }
                        }
                    }
            }
        }
    }

复杂度分析：

3.踩坑心得

关于答题-4:

个人感觉这次的题目的测试点还是比较正常的也没有什么测试点，把正常逻辑写完之后应该差不多了，但是要说的一点是，对于选择题信息的提取有一些问题，如果只用分组的话可能会提取到一些没有用的东西，所以这一块我使用的是切割,还有填空题一定要注意空格处理，我在这里卡了好久。

关于电路-1：

1.关于调速器的档位，这次迭代的调速器在调档的时候如果大于3就不再往上调，如果降档，则降到0档不能再往下降
2.第二个就是输出问题，需要按照一定的顺序

关于电路-2：

1.如果有一路的开关没有闭合，当传回电阻时不能传0，因为并联电路会用到电阻的倒数，会让数据出现问题，所以直接传一个负数，在并联电路里求电阻的时候如果是负数就不考虑这条路
2.不能用电流求电器的转数或者亮度，会有误差

4.改进建议

在对字符串进行操作时，对于频繁的字符串操作，应该使用StringBuilder或StringBuffer类来提高效率。

对于代码异常情况，使用try-catch语句块来捕获和处理异常，以保证程序的稳定性和可靠性。

通过继承，多态进一步完善判定逻辑。如多个并，串联电路。

5.总结

通过本阶段的三次题目集的练习，

1. 数据结构：我更加熟悉了使用List和Map等数据结构来处理和存储数据。这些数据结构在不同的情境下具有不同的优势，需要根据实际需求选择适当的数据结构。
2. 循环和条件语句：更熟悉了使用增强for循环和if-else条件语句来实现程序的控制流程，包括遍历数据、判断条件和执行不同的操作。
3. 字符串处理：更熟练使用字符串操作的方法，如分割、替换和拼接字符串，以及比较字符串和提取子字符串。
4. 学会了抽象类的基本应用。

需要进一步学习和研究的地方包括：

1. 异常处理：在给定的代码示例中，并未完全处理输入错误或无效数据的情况。学习处理异常，以提高程序的健壮性。
2. 更多的数据结构和算法：除了示例中涉及到的数据结构，还有许多其他的数据结构和算法可供学习和探索。了解不同的数据结构和算法可以帮助我更高效地解决问题。
3. 面向对象编程原则：学习如何设计良好的类和对象，并遵循面向对象编程的原则。这将使代码更加可维护、可扩展和可重用。

总体而言，我已经掌握了更多Java编程的基础知识和技巧，但仍有许多内容需要进一步学习和研究。通过不断练习、听讲，阅读文章和参考优秀的代码示例，我相信可以不断提升自己的编程能力和解决问题的能力。