Blog 1-3总结
1.前言
三个礼拜左右的pta训练，让我成功认知到了学校对java这门课程的重视。
总体而言，这三次pta难度都是比较大的，让我的头发掉了一根又一根，而且题目难度跨度太大了，让人有点难以适应，也是因为难度跨度很大，导致分数的分配也不是很均匀。还有就是有些测试点真的有点奇怪，让我苦苦思索了很久，改了一遍又一遍。
最后就是关于知识点方面了，题目集涵盖了正则表达式、列表、泛型和类间关系等等。正则表达式用于文本匹配和验证；列表是有序数据集合，支持增删改查操作；泛型增加代码灵活性，允许类或方法在不同类型上工作；类间关系包括继承、实现、关联、聚合和组合，描述了类之间的连接和交互。
2.设计与分析
答题判题程序-1
题目与源码分析
该代码的对象，类及类间关系
对象：
Main: 主类，包含程序的入口点，负责调用输入处理和输出处理的方法。
DealInput: 处理输入的类，负责读取用户输入的题目和答案，并进行相应的处理。
DealOutput: 处理输出的类，负责生成和输出结果。
TiMu: 表示题目的类，包含题号、题目内容和正确答案。
类及类间关系：
Main与DealInput之间的关系：Main类通过创建DealInput对象来调用处理输入的方法，从而完成输入的处理。
Main与DealOutput之间的关系：Main类通过创建DealOutput对象来调用处理输出的方法，从而完成输出的处理。
DealInput与TiMu之间的关系：DealInput类使用TiMu类来表示题目，DealInput类包含一个ArrayList<TiMu>来存储题目列表。
DealOutput与DealInput之间的关系：DealOutput类使用DealInput类来获取处理好的题目和答案，然后生成相应的输出结果。
DealOutput与TiMu之间的关系：DealOutput类使用TiMu类来获取题目的内容和正确答案，以便生成输出结果。
以下为源码：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
//判题程序
static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
int n = scanner.nextInt();//题目数量
scanner.nextLine();
dealInput dealInput = new dealInput();
dealInput.deal_input_tihao_timu(n);
dealInput.deal_input_zuodaArea();
dealInput.deal_input_end();
dealOutput dealOutput = new dealOutput();
dealOutput.deal_output_ans(n, dealInput);
dealOutput.output_judge(n);
}
}
class dealInput{
TiMu tiMu;
ArrayList<TiMu> list;
ArrayList<String> zuoda_list;
public dealInput() {
list = new ArrayList<TiMu>();
zuoda_list = new ArrayList<String>();
}
public void deal_input_tihao_timu(int n) {
for (int i = 0; i < n; i++) {
String str = Main.scanner.nextLine();
String[] arr = str.split("#");
int q = 0, w = 0;
for(int j = 2;j < arr[1].length();j++){
if(arr[1].charAt(j) != ' '){
q = j;
for(int k = arr[1].length() - 1;k >= 2;k--){
if(arr[1].charAt(k) != ' '){
w = k + 1;
break;
}
}
break;
}
}
String s = arr[1].substring(q, w);
int num = Integer.parseInt(s);
for(int j = 2;j < arr[2].length();j++){
if(arr[2].charAt(j) != ' '){
q = j;
break;
}
}
for(int j = arr[2].length() - 1;j >= 2 ;j--){
if(arr[2].charAt(j) != ' '){
w = j + 1;
break;
}
}
String contextString = arr[2].substring(q, w);
for(int j = 2;j < arr[3].length();j++){
if(arr[3].charAt(j) != ' '){
q = j;
break;
}
}
for(int j = arr[3].length() - 1;j >= 2 ;j--){
if(arr[3].charAt(j) != ' '){
w = j + 1;
break;
}
}
String ans = arr[3].substring(q, w);
tiMu = new TiMu(num, contextString, ans);
list.add(tiMu);
}
Collections.sort(list);
}
public void deal_input_zuodaArea() {
String str = Main.scanner.nextLine();
String[] arr = str.split("#");
for(int i = 1;i < arr.length;i++){
String s = arr[i];
int q = 0, w = 0;
for(int j = 2;j < s.length();j++){
if(s.charAt(j) != ' '){
q = j;
for(int k = s.length() - 1;k>=2;k--){
if(s.charAt(k) != ' '){
w = k + 1;
break;
}
}
break;
}
}
String ans = arr[i].substring(q, w);
zuoda_list.add(ans);
}
}
public void deal_input_end() {
String input;
while (true) {
input = Main.scanner.nextLine();
if (input.equals("end")) {
break;
}
}
}
}
class dealOutput{
dealInput dealInput;
ArrayList<Integer> ansList;
ArrayList<String> judgeList;
public dealOutput() {
ansList = new ArrayList<Integer>();
judgeList = new ArrayList<String>();
}
public void deal_output_ans(int n,dealInput dealInput) {
ArrayList<TiMu> tiMusList = dealInput.list;
ArrayList<String> asList = dealInput.zuoda_list;
for (int i = 0; i < n; i++) {
String suanShi_ans = tiMusList.get(i).getContext()+"~";
System.out.println(suanShi_ans + asList.get(i));
//System.out.println(suanShi_ans);
}
for (int i = 0; i < n; i++) {
String ans_zuoda = tiMusList.get(i).getAns();
if (ans_zuoda.equals(asList.get(i))) {
String s = "true";
judgeList.add(s);
}else {
String s = "false";
judgeList.add(s);
}
}
}
public void output_judge(int n) {
for (int i = 0; i < n; i++) {
if(i!=n-1) {
System.out.print(judgeList.get(i)+" ");
}else {
System.out.print(judgeList.get(i));
}
}
}
}
class TiMu implements Comparable<TiMu>{
private int num;
private String context;
private String ans;
public TiMu(int num,String contextString,String ans) {
this.num = num;
this.context = contextString;
this.ans = ans;
}
@Override
public String toString() {
return "题号: " + num + ", 题目内容: " + context + ", 答案: " + ans;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getContext() {
return context;
}
public void setContext(String context) {
this.context = context;
}
public String getAns() {
return ans;
}
public void setAns(String ans) {
this.ans = ans;
}
@Override
public int compareTo(TiMu o) {
// TODO Auto-generated method stub
return Integer.compare(this.num, o.num);
}
}
程序流程：
输入阶段：
主类Main的main方法首先被执行，程序开始运行。
从标准输入中读取一个整数n，表示题目的数量。
创建DealInput对象dealInput。
调用dealInput对象的dealInputTihaoTimu方法，处理题目和答案的输入。
循环读取n行题目信息，每行包含题号、题目内容和正确答案，将其封装成TiMu对象，并按题号排序后存储到题目列表中。
调用dealInput对象的dealInputZuodaArea方法，处理左答区的输入。
读取一行左答区的信息，将其中的答案依次存储到答案列表中。
调用dealInput对象的dealInputEnd方法，处理输入结束的标志。
循环读取输入，直到遇到"end"为止。
处理输出：
创建DealOutput对象dealOutput。
调用dealOutput对象的dealOutputAns方法，处理输出结果。
遍历题目列表和答案列表，依次输出题目内容和左答区的对应答案。
比较题目的正确答案和左答区的答案，生成判断结果，并存储到判断结果列表中。
调用dealOutput对象的outputJudge方法，输出最终的判断结果。
遍历判断结果列表，将结果按要求输出到标准输出。
程序结束：
整个程序执行完成，结束运行。
解题心得：
模块化设计：将程序分成输入处理、输出处理和主控制流程模块，有助于代码组织和维护。
数据结构选择：使用ArrayList存储题目和答案，TiMu类表示题目，简化管理和操作。
算法思路：通过循环遍历题目和答案列表，比对左答区和正确答案，得出判断结果并输出。
错误处理：考虑用户可能的错误输入，如负数题目数量或空题目内容，添加适当的错误处理和提示。
代码风格和规范：保持良好的代码风格和命名规范，添加注释和文档说明，提高代码可读性和可维护性。
答题判题程序-2
题目与源码分析
该代码的对象，类及类间关系：
Question（题目）：
属性：题目编号（number）、内容（content）、答案（answer）
方法：构造函数、getter和setter方法
TestPaper（试卷）：
属性：试卷编号（number）、题目编号列表（questionNumbers）、题目分数列表（questionScores）、是否满分（is100）
方法：构造函数、添加题目及分数方法（addQuestionScore）、设置是否满分方法（setIs100）
AnswerSheet（答题卡）：
属性：试卷编号（testPaperNumber）、答案列表（answers）
方法：构造函数、添加答案方法（addAnswer）
Main（主程序）：
主要负责解析输入，构建题目、试卷和答题卡对象，以及计算得分和输出结果。
这些类之间的关系如下：
TestPaper类包含多个Question对象，表示试卷包含多道题目。
AnswerSheet类与TestPaper类相关联，每个AnswerSheet对象对应一个TestPaper对象。
Main类协调整个程序的执行过程，负责输入解析、对象构建、得分计算和结果输出。
以下为源码:
import java.util.*;
class Question {
String number;
String content;
String answer;
public Question(String number, String content, String answer) {
this.number = number;
this.content = content;
this.answer = answer;
}
}
class TestPaper {
String number;
Boolean is100;
List<String> questionNumbers;
List<Integer> questionScores;
int size;
public TestPaper(String number) {
this.number = number;
this.questionScores = new ArrayList<>();
this.questionNumbers = new ArrayList<>();
this.size = 0;
}
public void addQuestionScore(String questionNumber, int score) {
questionNumbers.add(questionNumber);
questionScores.add(score);
size++;
}
public void setIs100(){
int sum = 0;
for(int i = 0;i<size;i++){
sum += questionScores.get(i);
}
is100 = sum == 100;
}
}
class AnswerSheet {
String testPaperNumber;
List<String> answers;
public AnswerSheet(String testPaperNumber) {
this.testPaperNumber = testPaperNumber;
this.answers = new ArrayList<>();
}
public String getTestPaperNumber(){
return testPaperNumber;
}
public void addAnswer(String answer) {
answers.add(answer);
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Map<String, Question> questions = new HashMap<>();
Map<String, TestPaper> testPapers = new HashMap<>();
List<AnswerSheet> answerSheets = new ArrayList<>();
String input;
while (!(input = scanner.nextLine()).equals("end")) {
if (input.startsWith("#N:")) {
String[] parts = input.split(" ");
String number = parts[0].substring(3);
String content = parts[1].substring(3);
String answer = parts[2].substring(3);
questions.put(number, new Question(number, content, answer));
} else if (input.startsWith("#T:")) {
String[] parts = input.split(" ");
String testPaperNumber = parts[0].substring(3);
TestPaper testPaper = new TestPaper(testPaperNumber);
for (int i = 1; i < parts.length; i++) {
String[] questionScore = parts[i].split("-");
testPaper.addQuestionScore(questionScore[0], Integer.parseInt(questionScore[1]));
}
testPaper.setIs100();
testPapers.put(testPaperNumber, testPaper);
} else if (input.startsWith("#S:")) {
String[] parts = input.split(" ");
String testPaperNumber = parts[0].substring(3);
AnswerSheet answerSheet = new AnswerSheet(testPaperNumber);
for (int i = 1; i < parts.length; i++) {
answerSheet.addAnswer(parts[i].substring(3));
}
answerSheets.add(answerSheet);
}
}
// 按照testPaperNumber排序
Collections.sort(answerSheets, Comparator.comparing(AnswerSheet::getTestPaperNumber));
Map<String, Boolean> mp = new HashMap<>();
for (AnswerSheet answerSheet : answerSheets) {
TestPaper testPaper = testPapers.get(answerSheet.testPaperNumber);
int totalScore = 0;
Boolean alert = mp.get(answerSheet.testPaperNumber);
if(alert != null){
}
else{
if(!testPaper.is100){
alert = true;
System.out.println("alert: full score of test paper" + testPaper.number + " is not 100 points");
}
mp.put(answerSheet.testPaperNumber, true);
}
if (testPaper != null) {
Boolean p = true;
StringBuilder scoreInfo = new StringBuilder();
for (int i = 0; i < answerSheet.answers.size(); i++) {
//String questionNumber = testPaper.questionScores.keySet().toArray()[i].toString();
String questionNumber = testPaper.questionNumbers.get(i);
int score = testPaper.questionScores.get(i);
Question question = questions.get(questionNumber);
if (question != null) {
String answer = answerSheet.answers.get(i);
boolean isCorrect = answer.equals(question.answer);
if(p){
if(isCorrect)
scoreInfo.append(testPaper.questionScores.get(i));
else
scoreInfo.append("0");
p = false;
}
else{
if(isCorrect)
scoreInfo.append(" ").append(testPaper.questionScores.get(i));
else
scoreInfo.append(" ").append("0");
}
totalScore += isCorrect ? score : 0;
System.out.println(question.content + "~" + answer + "~" + isCorrect);
}
}
System.out.println(scoreInfo + "~" + totalScore);
} else {
System.out.println("The test paper number does not exist");
}
}
}
}
程序流程：
初始化阶段：
创建Scanner对象用于接收用户输入。
创建空的题目、试卷和答题卡对象的容器（Map或List）。
通过循环读取用户输入，解析输入内容，并根据输入内容创建题目、试卷和答题卡对象，并存储到相应的容器中，直到输入结束标志"end"。
得分计算阶段：
对于每个答题卡对象，获取对应的试卷对象。
遍历试卷中的题目，逐一与答题卡中的答案进行比对，计算得分。
如果试卷总分不为100，则输出警告信息。
结果输出阶段：
对于每个答题卡对象，逐一输出每道题目的内容、答案、是否正确，并显示总得分。
程序结束：
关闭Scanner对象。
程序执行完毕。
解题心得：
面向对象设计：代码采用面向对象的设计方式，将题目、试卷和答题卡等实体抽象成对象，使程序结构清晰，易于理解和维护。
模块化开发：将功能模块拆分成不同的类，每个类负责特定的功能，有利于代码复用和维护。例如，题目、试卷和答题卡分别由不同的类来表示和管理。
输入解析：程序能够有效地解析用户输入，根据输入内容动态创建题目、试卷和答题卡对象，这样的设计使程序更加灵活，能够处理不同格式的输入数据。
逻辑清晰：通过主程序的流程分析，可以看出程序的逻辑清晰，按照初始化、得分计算和结果输出的顺序执行，每个阶段的任务明确，易于理解。
错误处理：虽然代码片段并未显示完整的错误处理机制，但在实际应用中，需要考虑到各种可能的错误情况，例如输入格式错误、题目编号重复等，对这些情况进行适当的处理和提示。
答题判题程序-3
题目与源码分析
第三次就会很麻烦，相较于第二次添加了很多内容，就不多说，直接给出解决办法
先要考虑的是处理多种错误报告的优先级。一种常见的方法是定义一个错误代码或类型，并为每种错误分配一个优先级。例如：
1 表示输入格式错误
2 表示引用题目不存在
3 表示引用题目被删除
4 表示答卷无对应题目
5 表示答卷无对应试卷
6 表示学号无对应学生
然后，可以根据这些优先级在程序中处理错误，确保最重要的错误首先被解决。
接下来，让我们来看看类的设计：
题目类（Text）：包含题目编号、题目内容和题目答案等属性。
试卷类（Paper）：包含试卷编号、试卷内题目编号、题目回答、试卷内总题数、试卷总得分、试卷每题分数等属性。
答卷类（AnswerSheet）：包含答卷编号、答卷总数、答卷内答案、得分结果等属性。
删除类（Delete）：包含被删除题号等属性。
学生类（Student）：包含学生学号和学生姓名等属性。
操作类（Operation）：包含所有题目信息、所有试卷信息、所有答卷信息等属性和方法，用于操作题目、试卷和答卷。
在操作类中，你可以设计各种方法来处理输入、检查错误、添加题目、删除题目、生成试卷、批改答卷等功能。同时，你还可以在操作类中实现处理错误报告的逻辑，根据错误优先级逐一处理错误。
对于格式错误，可以设计一个方法来检查输入是否符合规定的格式，如果不符合，则返回错误代码 1；对于其他错误，可以在相应的操作方法中进行检查并返回相应的错误代码。
在类的设计中，要考虑到每个类的属性和方法，确保它们能够满足需求，并且类之间的关系清晰明了，便于代码的编写和维护。
踩坑心得：
1.错误报告的优先级管理：**确保设计一个清晰的错误代码体系，并根据错误的严重程度分配优先级。在处理错误时，要按照优先级逐一解决，确保最重要的错误首先被处理。
2.多种错误同时发生时的处理：**由于一个输入可能同时存在多种错误，因此在处理错误时要考虑到这种情况。可以使用递归或者嵌套的方式来处理多种错误，确保每种错误都得到了适当的处理。
3.输入格式错误的检查：**设计一个严格的输入格式检查机制，确保用户输入的数据符合规定的格式。可以使用正则表达式或者自定义的输入检查函数来实现。
4.异常情况的处理：**在设计类的方法时，要考虑到各种可能的异常情况，并在方法中加入相应的异常处理逻辑，确保程序能够在异常情况下正常运行。
5.类之间的关系管理：**要确保类之间的关系清晰明了，避免出现循环依赖或者过度耦合的情况。可以使用接口、抽象类等技术来管理类之间的关系。
6.代码的模块化和复用：**尽量将功能相似的代码封装成独立的模块或者函数，提高代码的复用性和可维护性。可以使用面向对象的设计原则来组织代码结构，确保代码的清晰易懂。
7.测试和调试：**在设计完成后，一定要进行充分的测试和调试，确保程序能够正常运行并且能够正确处理各种异常情况。可以使用单元测试、集成测试等方法来验证程序的正确性。
总的来说，在处理复杂逻辑和错误报告时，要保持代码的清晰简洁，合理划分模块和功能，注重异常情况的处理，确保程序的稳定性和可靠性。同时，要不断学习和积累经验，及时总结和解决遇到的问题，提高自己的编程能力。
改进建议：
题目难度跨度较大，分数分配不均
总结：
这三次pta真的让我有点苦不堪言，但求学路上总是又很多苦难，只能一个一个的去克服，加油呗。
标签：题目,String,Blog1,int,ans,new,public From： https://www.cnblogs.com/lyh971433/p/18149585