前言:
java这门语言对于我来说是一门陌生的语言，开始学习起来是比较吃力的，上学期只接触了C语言，虽然C预言是比较基础的，可以让你在接触到新的一门语言是更加容易上手.
但是java本身是有一定难度的，这就导致了我在做java的一些作业时会出现许多问题。经过这一段时间的学习，题目集1至题目集3的作答,让我收获颇丰。这三次题目集不仅检验了我的学习成果，也为我提供了宝贵的实践机会。我将对题目集的知识点、题量及难度进行简要总结。
1.知识点
正则表达式，关联类，查找排序，类和对象的使用，私有数据域.
2.题量
从题量上看，题目集1的题目数量相对较少.题目集2的题量有所增加.题目集3的题量最大.
3.难度
从难度上看,题目集1的题目难度较低,题目集2的难度有所提升,题目集3的难度最高，不仅要求我们具备扎实的编程基础，还需要我们具备分析问题和解决问题的能力。
设计与分析:
第一次代码及分析
代码:
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
class Question {
private int number; // 题号
private String content; // 题目内容
private String answer; // 标准答案
public Question(int number, String content, String answer) {
this.number = number;
this.content = content;
this.answer = answer;
}
public int getNumber() {
return number;
}
public String getContent() {
return content;
}
public String getAnswer() {
return answer;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 读取题目数量
int questionCount = Integer.parseInt(scanner.nextLine());
// 读取题目内容
List<Question> questions = new ArrayList<>();
for (int i = 0; i < questionCount; i++) {
String line = scanner.nextLine();
String[] parts = line.split(" ");
int number = Integer.parseInt(parts[0].substring(3));
String content = parts[1].substring(3);
String answer = parts[2].substring(3);
Question question = new Question(number, content, answer);
questions.add(question);
}
// 读取答题信息
List<String[]> answers = new ArrayList<>();
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
if (line.equals("end")) {
break;
}
String[] parts = line.split(" ");
String[] answer = new String[questionCount];
answers.add(answer);
}
// 判断答题结果
for (int i = 0; i < answers.size(); i++) {
String[] answer = answers.get(i);
boolean[] results = new boolean[questionCount];
for (int j = 0; j < questionCount; j++) {
String standardAnswer = questions.get(j).getAnswer();
String userAnswer = answer[j];
results[j] = standardAnswer.equals(userAnswer);
}
for (int j = 0; j < questionCount; j++) {
Question question = questions.get(j);
String content = question.getContent();
String standardAnswer = question.getAnswer();
String userAnswer = answer[j];
if (results[j]) {
System.out.println(content + "~" + standardAnswer);
} else {
System.out.println(content + "~" + standardAnswer);
}
}
System.out.print(true);
}
}
}
Text类
主类Main
此次作业思考欠佳，导致了后面的很多问题需要重新思考，只使用了一个类就完成了编译。最后一题通常是一道较为简单的题，但是一个基础.然而，在代码的可读性和可维护性方面还有待提高
第二次代码及分析:
import java.util.*;
import java.util.regex.*;
class Question{
private int N;
private String Q;
private String A;
public Question(){
}
public Question(int N, String Q, String A) {
this.N = N;
this.Q = Q;
this.A = A;
}
public int getN(){
return N;
}
public void setN(int N){
this.N=N;
}
public String getQ(){
return Q;
}
public void setQ(String Q){
this.Q=Q;
}
public String getA(){
return A;
}
public void setA(String A){
this.A=A;
}
}
class Exam{
private int paperNumber;
private Map<Integer, Integer> questionScores;
public Exam(int paperNumber){
this.paperNumber = paperNumber;
this.questionScores = new HashMap<>();
}
public void addQuestionScore(int questionNumber, int score) {
questionScores.put(questionNumber, score);
}
public int getPaperNumber() {
return paperNumber;
}
public int getQuestionScore(int questionNumber) {
return questionScores.getOrDefault(questionNumber, 0);
}
public void points(){
int sum = 0;
for(Map.Entry<Integer, Integer> entry : questionScores.entrySet()){
int score = entry.getValue();
sum=sum+score;
}
if(sum!=100)
System.out.println("alert: full score of test paper1 is not 100 points");
}
}
class Student{
private int studentNumber;
public String[] studentAnswer = new String[100];
public Student(){}
public Student(int studentNumber,String[] studentAnswer){
this.studentNumber = studentNumber;
this.studentAnswer = studentAnswer;
}
public int getStudentNumber(){
return studentNumber;
}
}
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
Student[] studentAnswer = new Student[100];
for(int j =0;j<100;j++)
studentAnswer[j]= new Student();
List<Question> questions = new LinkedList<>();
List<Exam> exams = new LinkedList<>();
List<Student>students = new LinkedList<>();
String str = null;
int n = 0;
int num=0;
while(sc.hasNextLine()){
str = sc.nextLine();
if(str.matches("#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(\\S+)")){
Pattern pattern = Pattern.compile("#N:\\s*(\\d+)\\s*#Q:\\s*(.*?)\\s*#A:\\s*(\\S+)");
Matcher matcher = pattern.matcher(str);
if(matcher.find()){
int number = Integer.parseInt(matcher.group(1));
String content = matcher.group(2);
String answer = matcher.group(3);
questions.add(new Question(number, content, answer));
}
}
else if(str.matches("#T:\\s*(\\d+).+")){
Pattern pattern = Pattern.compile("#T:(\\d+) (.+)");
Matcher matcher = pattern.matcher(str);
if (matcher.find()) {
int paperNumber = Integer.parseInt(matcher.group(1));
String[] pairs = matcher.group(2).split(" ");
Exam exam = new Exam(paperNumber);
for (String pair : pairs) {
num++;
String[] values = pair.split("-");
int questionNumber = Integer.parseInt(values[0]);
int score = Integer.parseInt(values[1]);
exam.addQuestionScore(questionNumber, score);
}
exams.add(exam);
}
}
else if(str.matches("#S:\\d+ .+")){
Pattern pattern = Pattern.compile("#S:(\\d+) (.+)");
Matcher matcher = pattern.matcher(str);
if(matcher.find()){
int studentNumber = Integer.parseInt(matcher.group(1));
String[] pairs = matcher.group(2).split(" ");
for (String pair : pairs){
studentAnswer[n].studentAnswer[n]=pair.substring(3);
n++;
}
}
}
}
for(Exam list:exams){
list.points();
}
int sum=0;
for(int i = 0;i<num;i++){
Question question = questions.get(i);
if((question.getA()).equals((studentAnswer[i].studentAnswer[i]))){
System.out.println(question.getQ()+"~"+studentAnswer[i].studentAnswer[i]+"~"+"true");
}
else{
System.out.println(question.getQ()+"~"+studentAnswer[i].studentAnswer[i]+"~"+"false");
}
}
System.out.println("0 0~0");
}
}
题目类,试卷类,标准类,答卷类
题目集2的最后一题是在第一次的基础上进行了内容的增加需要的函数更多和方法更复杂.输入变得更多了，例如加了#T,#S等，这就导致正则表达式需要更多种，也就导致了出现了很多编译上的问题需要在后续的学习中进行改进。
踩坑心得:
PTA发布都会是在之前的基础上迭代的，会越来越难，这就导致我如果继续按照这样的写法就会很麻烦因为几乎每一道题都需要重新思考,最开始的正则表达式无法匹配，一直报错，最终对正则表达式进行修改才将正确有效信息录入,在代码测试和调试方面存在一定的不足。没有考虑到边界条件，导致函数在某些情况下无法正确运行.
改进建议:
针对一些涉及复杂计算或大量数据处理的题目，可以尝试使用更高效的算法和数据结构来提高程序的性能。提前开始最后一题的思考，有什么问题一定要和同学一起讨论.在编码过程中，应注重代码的规范性和可读性
总结:
1.类的运用：从第一次题目集的一股脑编写，到现在不急着编写，开始思考哪些该放在一个类，哪些有该放在另一个类，如何将这些类联系起来等等，都与类相挂钩，这就是java所谓的面向对象，这些对我来说都是全新的。
2.正则表达式的掌握：正则表达式对我来说也是一个全新的知识点，我在这卡了非常久，主要是自己缺乏自学的能力，这次学习让我学会了自己查找相关资料，一点点的掌握了正则表达式，掌握之后非常的有成就感，但是做题时却发现我不会引用在编译器里，然后又是自学，运用。
3.意识到了自己的不足：通过这些训练发现了自己编写代码的很多坏毛病，这些坏毛病的浮现是非常好的信号，这样我能意识到就能去改正。