对于前三次pta作业的总结
一.前三次作业分析
二.自己学到了什么
一.前三次作业分析
1.第一次作业：
在我们的第一次pta作业上，我们程序输入信息分三部分，分别是#N一部分#Q一部分和#A一部分，这三部分分别表示题目的题号，题目的内容和题目的答案还有标准答案。
根据这题题目的意思，我们要用正则表达式对题目进行切割，然后分别把题目编号，题目内容，学生答案和试卷标准答案提取出来。
然后设置三个类：
（1）一个是题目类（用于封装单个题目的信息），我们要用这个试卷类来储存题目编号、题目内容和标准答案，然后用学生答案返回来与标准答案进行匹配，如果一致则说明回答正确，反之则回答错误。
这第一个试卷类是为了给第二个试卷类提供更好的储存题目的方法。
（2）第二个则是试卷类（用于封装整套题目的信息），试卷类包含有题目列表(题目类的对象集合)和题目数量，在试卷类里面我们可以用来判断学生的答案是否正确（这是基于第一个题目类来返回true或者false）。
我们还可以在试卷类里面将题目保存到题目列表中，保存位置与num要能对应。这样我们在后续写题目的过程中能够更加简便的找到自己所需要使用的题目。
（3）第三个则是答卷类（用于封装答题信息），答卷类包含：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）。
判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案。
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。
这样一来简单的三个类就做好了，我们可以用这三个类来完成题目的要求（但是切记要满足单一职责原则）
第一次作业虽然比较非常简单，但我完成的并不是很好，具有很大意义。我第二次、第三次作业的架构都是在此基础上建立的。
`import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
class Problem {
private int number;
private String content;
private String standardAnswer;
public Problem(int number, String content, String standardAnswer) {
super();
this.number = number;
this.content = content;
this.standardAnswer = standardAnswer;
}
public Problem() {
super();
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public boolean judgeAnswer(String answer) {
return this.standardAnswer.equals(answer);
}
public String getproblem() {
return content + "~" + standardAnswer;
}
}
class Testpaper {
List
public Testpaper() {
super();
this.problemlist = new ArrayList<>();
}
public void addproblem(int number, String content, String standardAnswer) {
Problem problem = new Problem(number,content,standardAnswer);
problemlist.add(problem);
}
public void removeproblem(int number) {
int i=0;
for(i=0;i<99;i++)
{
if(this.problemlist.get(i).getNumber()==number)
{
problemlist.remove(i);
break;
}
}
}
public boolean judgeAnswer(int number,String answer) {
for(int i = 0;i<problemlist.size();i++)
{
if(problemlist.get(i).getNumber() == (number+1))
{
Problem problem = problemlist.get(i);
return problem.judgeAnswer(answer);
}
}
return false;
}
public String getproblem(int number) {
Problem problem = problemlist.get(number-1);
return problem.getproblem();
}
}
class Answerpaper {
List
List
List
private Testpaper testpaper;
public Answerpaper(Testpaper testpaper) {
super();
this.testpaper = testpaper;
this.answerlist=new ArrayList<>();
this.answernumberlist = new ArrayList<>();
this.numberlist = new ArrayList<>();
}
public void addAnswer(String answer) {
answerlist.add(answer);
}
public void addAnswernumber(int number) {
answernumberlist.add(number);
}
public void addnumber(int number) {
numberlist.add(number);
}
public boolean judgeAnswer(int number) {
String answer = answerlist.get(number);
return testpaper.judgeAnswer(number,answer);
}
public String getanswer(int number) {
return answerlist.get(number-1);
}
}
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner input = new Scanner(System.in);
Testpaper testpaper = new Testpaper();
Answerpaper answerpaper = new Answerpaper(testpaper);
int n = input.nextInt();
while (input.hasNextLine()) {
String sc = input.nextLine();
if (sc.startsWith("end")) {
break;
}
if(sc.startsWith("#N:")) {
//#N:1 #Q:1+1= #A:2
String parts[]=sc.split("#Q:|#A:|#N:");
testpaper.addproblem(Integer.parseInt(parts[1].trim()),parts[2].trim(),parts[3].trim());
}
//#A:2 #A:2
else if(sc.startsWith("#A:")) {
String parts[]=sc.split("#A:");
for(int i=0;i<parts.length-1;i++)
{
answerpaper.addAnswer(parts[i+1].trim());
}
}
}
for(int i=0;i<testpaper.problemlist.size();i++)
{
for(int j = 0;j<testpaper.problemlist.size();j++)
{
if(testpaper.problemlist.get(j).getNumber() == i+1) {
System.out.println(testpaper.problemlist.get(j).getContent()+"~"+answerpaper.answerlist.get(i));
}
}
}
for(int i=0;i<testpaper.problemlist.size();i++)
{
for(int j = 0;j<testpaper.problemlist.size();j++)
{
if(testpaper.problemlist.get(j).getNumber() == i+1) {
System.out.print(answerpaper.judgeAnswer(i));
if(i!=testpaper.problemlist.size()-1)
{
System.out.print(" ");
}
}
}
}
}
}
`
2.第二次作业：
**我们的第二次pta作业是基于第一次pta的作业基础上增加功能和实现功能的变换来实现的。
在这第二次作业上，我们程序输入信息分三种，三种信息可能会打乱顺序混合输入。
三种信息分别为：题目信息，试卷信息和答卷信息。
（1）题目信息： 一行为一道题，可输入多行数据（多道题）它的格式为："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
（2）试卷信息：一行为一张试卷，可输入多行数据（多张卷）它的格式："#T:"+试卷号+" "+题目编号+"-"+题目分值
（3）答卷信息： 答卷信息按行输入，每一行为一张答卷的答案，每组答格式："#S:"+试卷号+" "+"#A:"+答案内容。答案包含某个试卷信息中的题目的解题答案，答案的顺序与试卷信息中的题目顺序相对应。
输出格式：
（1）试卷总分警示，该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100分，该部分忽略，不输出。格式："alert: full score of test paper"+试卷号+" is not 100 points"。
（2）答卷信息，一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。格式：题目内容+""+答案++""+判题结果（true/false）。约束：如果输入的答案信息少于试卷的题目数量，答案的题目要输"answer is null"
（3）判分信息，判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。格式：题目得分+" "+....+题目得分+"~"+总分
（4）提示错误的试卷号，如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”
以上为这第二次作业的输入和输出格式，我们是在第一次作业的基础上可以增加一个得分类，根据学生的答案的正确与否来显示学生所得的分数。
这里我们同样和第一道题目一样要考虑使用正则表达式来分割题目，并且使用列表来储存内容信息。还有一点要注意的就是输入的题目要严格按照题目的要求来。
`import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
class Problem {
private int number;
private String content;
private String standardAnswer;
public Problem(int number, String content, String standardAnswer) {
super();
this.number = number;
this.content = content;
this.standardAnswer = standardAnswer;
}
public Problem() {
super();
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public boolean judgeAnswer(String answer) {
return this.standardAnswer.equals(answer);
}
public String getproblem() {
return content + "~" + standardAnswer;
}
}
class Testpaper {
List
public Testpaper() {
super();
this.problemlist = new ArrayList<>();
}
public void addproblem(int number, String content, String standardAnswer) {
Problem problem = new Problem(number,content,standardAnswer);
problemlist.add(problem);
}
public void removeproblem(int number) {
int i=0;
for(i=0;i<99;i++)
{
if(this.problemlist.get(i).getNumber()==number)
{
problemlist.remove(i);
break;
}
}
}
public boolean judgeAnswer(int number,String answer) {
for(int i = 0;i<problemlist.size();i++)
{
if(problemlist.get(i).getNumber() == number)
{
Problem problem = problemlist.get(i);
return problem.judgeAnswer(answer);
}
}
return false;
}
public String getproblem(int number) {
Problem problem = problemlist.get(number-1);
return problem.getproblem();
}
}
class Answerpaper {
List
protected int papernumber;
public Answerpaper(int papernumber, List<String> answerlist) {
super();
this.answerlist = answerlist;
this.papernumber = papernumber;
}
public boolean judgeAnswer(int number) {
String answer = answerlist.get(number);
Testpaper testpaper = new Testpaper();
return testpaper.judgeAnswer(number,answer);
}
public String getanswer(int number) {
return answerlist.get(number-1);
}
public int getPapernumber() {
return papernumber;
}
public void setPapernumber(int papernumber) {
this.papernumber = papernumber;
}
}
class Score {
protected int papernumber;
List
List
public Score(int papernumber, List<Integer> scorelist, List<Integer> numberlist) {
super();
this.papernumber = papernumber;
this.scorelist = scorelist;
this.numberlist = numberlist;
}
public int getPapernumber() {
return papernumber;
}
public void setPapernumber(int papernumber) {
this.papernumber = papernumber;
}
}
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner input = new Scanner(System.in);
Testpaper testpaper = new Testpaper();
List<Answerpaper> answerpaperlist = new ArrayList<>();
List<Score> scorelist = new ArrayList<>();
int Snumber = 0;
int Tnumber = 0;
while (input.hasNextLine()) {
String sc = input.nextLine();
if (sc.equals("end")) {
break;
}
if(sc.startsWith("#N:")) {
//#N:1 #Q:1+1= #A:2
String parts[]=sc.split("#Q:|#A:|#N:");
testpaper.addproblem(Integer.parseInt(parts[1].trim()),parts[2].trim(),parts[3].trim());
}
//#S:1 #A:5 #A:4
else if(sc.startsWith("#S:")) {
String parts[]=sc.split("#S:|#A:");
int num = Integer.parseInt(parts[1].trim());
List<String> answers= new ArrayList<>();
for(int i=0;i<parts.length-2;i++)
{
answers.add(parts[i+2].trim());
}
answerpaperlist.add(new Answerpaper(num, answers));
Snumber ++;
}//#T:1 3-70 2-30
else if(sc.startsWith("#T")) {
String parts[]=sc.split(" |#T:");
int num = Integer.parseInt(parts[1].trim());
List<Integer> score1 = new ArrayList<>();
List<Integer> number = new ArrayList<>();
for(int i = 0;i<parts.length-2;i++)
{
String parts1[] = parts[i+2].split("-");
score1.add(Integer.parseInt(parts1[1].trim()));
number.add(Integer.parseInt(parts1[0].trim()));
}
scorelist.add(new Score(num,score1,number));
Tnumber++;
}
}
for(int i = 0;i<Tnumber;i++)
{
int sum = 0;
for(int j = 0;j<scorelist.get(i).scorelist.size();j++)
{
sum = sum + scorelist.get(i).scorelist.get(j);
}
if(sum<100) {
System.out.println("alert: full score of test paper"+ scorelist.get(i).papernumber+" is not 100 points");
}
}
int []sum = new int [0] ;
for(int i = 0;i<Snumber;i++)
{
int g;
for(g = 0;g < Tnumber;g++)
{
if(scorelist.get(g).papernumber == answerpaperlist.get(i).papernumber)
{
break;
}
}
if(g==Tnumber)
{
System.out.println("The test paper number does not exist");
break;
}
for(int j = 0;j<answerpaperlist.get(i).answerlist.size();j++)
{
for(int t = 0;t<testpaper.problemlist.size();t++)
{
if(testpaper.problemlist.get(t).getNumber()==scorelist.get(g).numberlist.get(j))
{
sum = Arrays.copyOf(sum, sum.length+1);
System.out.println(testpaper.problemlist.get(t).getContent()+"~"+answerpaperlist.get(i).answerlist.get(j)+"~"+testpaper.judgeAnswer(testpaper.problemlist.get(t).getNumber(),answerpaperlist.get(i).answerlist.get(j)));
if(testpaper.judgeAnswer(testpaper.problemlist.get(t).getNumber(),answerpaperlist.get(i).answerlist.get(j)))
{
sum[j] = scorelist.get(g).scorelist.get(j);
}
else
sum[j]=0;
break;
}
}
}
if(answerpaperlist.get(i).answerlist.size()<scorelist.get(g).numberlist.size())
{
int b=0;
for(b=scorelist.get(g).numberlist.size()-answerpaperlist.get(i).answerlist.size();b>0;b--)
{
System.out.println("answer is null");
}
}
int num = 0;
for(int x = 0;x<scorelist.get(g).scorelist.size();x++)
{
num = sum[x] + num;
if(x!=scorelist.get(g).scorelist.size()-1) {
System.out.print(sum[x]+" ");
}
else if(x==scorelist.get(g).scorelist.size()-1&&i!=Snumber-1){
System.out.println(sum[x]+"~"+num);
}
else if(x==scorelist.get(g).scorelist.size()-1&&i==Snumber-1){
System.out.print(sum[x]+"~"+num);
}
}
}
}
}
`
3.第三次作业：
我们的第三次pta作业是基于前两次pta的作业基础上增加功能和实现功能的变换来实现的。
这第三次程序输入信息分五种，信息可能会打乱顺序混合输入。
（1）题目信息：题目信息为独行输入，一行为一道题，多道题可分多行输入。格式："#N:"+题目编号+" "+"#Q:"+题目内容+" "#A:"+标准答案
（2）试卷信息：试卷信息为独行输入，一行为一张试卷，多张卷可分多行输入数据。格式："#T:"+试卷号+" "+题目编号+"-"+题目分值+" "+题目编号+"-"+题目分值+...
（3）学生信息：学生信息只输入一行，一行中包括所有学生的信息，每个学生的信息包括学号和姓名。格式："#X:"+学号+" "+姓名+"-"+学号+" "+姓名....+"-"+学号+" "+姓名
（4）答卷信息：答卷信息按行输入，每一行为一张答卷的答案每组答案包含某个试卷信息中的题目的解题答案，答案的顺序号与试 卷信息中的题目顺序相对应。格式："#S:"+试卷号+" "+学号+" "+"#A:"+试卷题目的顺序号+"-"+答案内容+...
（5）删除题目信息： 删除题目信息为独行输入，每一行为一条删除信息，多条删除信息可分多行输入。该信息用于删除一道题目信息，题目被删除之后，引用该题目的试卷依然有效，但被删除的题目将以0分计，同时在输出答案时，题目内容与答案改为一条失效提示，例如：”the question 2 invalid~0”。格式："#D:N-"+题目号。
输出格式：
（1）试卷总分警示，该部分仅当一张试卷的总分分值不等于100分时作提示之用，试卷依然属于正常试卷，可用于后面的答题。如果总分等于100 分，该部分忽略，不输出。格式："alert: full score of test paper"+试卷号+" is not 100 points"。
（2）答卷信息，一行为一道题的答题信息，根据试卷的题目的数量输出多行数据。格式：题目内容+""+答案++""+判题结果（true/false）。
（3）判分信息， 判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。格式：学号+" "+姓名+": "+题目得分+" "+....+题目得分+"~"+总分
（4）被删除的题目提示信息，当某题目被试卷引用，同时被删除时，答案中输出提示信息。
（5）题目引用错误提示信息，试卷错误地引用了一道不存在题号的试题，在输出学生答案时，提示”non-existent question~”加答案。
（6）格式错误提示信息，输入信息只要不符合格式要求，均输出”wrong format:”+信息内容。
（7）试卷号引用错误提示输出，如果答卷信息中试卷的编号找不到，则输出”the test paper number does not exist”，答卷中的答案不用输出。
（8）学号引用错误提示信息，如果答卷中的学号信息不在学生列表中，答案照常输出，判分时提示错误。
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
class Problem {
private int number;
private String content;
private String standardAnswer;
public Problem(int number, String content, String standardAnswer) {
super();
this.number = number;
this.content = content;
this.standardAnswer = standardAnswer;
}
public Problem() {
super();
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getStandardAnswer() {
return standardAnswer;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public boolean judgeAnswer(String answer) {
return this.standardAnswer.equals(answer);
}
public String getproblem() {
return content + "~" + standardAnswer;
}
}
class Testpaper {
List
public Testpaper() {
super();
this.problemlist = new ArrayList<>();
}
public void addproblem(int number, String content, String standardAnswer) {
Problem problem = new Problem(number,content,standardAnswer);
problemlist.add(problem);
}
public void removeproblem(int number) {
int i=0;
for(i=0;i<99;i++)
{
if(this.problemlist.get(i).getNumber()==number)
{
problemlist.remove(i);
break;
}
}
}
public boolean judgeAnswer(int number,String answer) {
Problem problem = problemlist.get(number);
return problem.judgeAnswer(answer);
}
public String getproblem(int number) {
Problem problem = problemlist.get(number-1);
return problem.getproblem();
}
public List
return problemlist;
}
}
class Answerpaper {
List
List
List
private Testpaper testpaper;
public Answerpaper(Testpaper testpaper) {
super();
this.testpaper = testpaper;
this.answerlist=new ArrayList<>();
this.answernumberlist = new ArrayList<>();
this.numberlist = new ArrayList<>();
}
public void addAnswer(String answer) {
answerlist.add(answer);
}
public void addAnswernumber(int number) {
answernumberlist.add(number);
}
public void addnumber(int number) {
numberlist.add(number);
}
public boolean judgeAnswer(int number) {
String answer = answerlist.get(number);
return testpaper.judgeAnswer(number,answer);
}
public String getanswer(int number) {
return answerlist.get(number-1);
}
}
class Score {
List
List
List
public Score() {
super();
this.scorelist = new ArrayList<>();
this.numberlist = new ArrayList<>();
this.scorenumberlist = new ArrayList<>();
}
public void addscore(int number,int score) {
numberlist.add(number);
scorelist.add(score);
}
public void addscorenumber(int scorenumber) {
scorenumberlist.add(scorenumber);
}
public List<Integer> getscore() {
return scorelist;
}
}
class Information {
List
List
public Information() {
super();
this.studentnumberlist = new ArrayList<>();
this.studentnamelist = new ArrayList<>();
}
public void addstudentnumber(int number) {
studentnumberlist.add(number);
}
public void addstudentname(String name) {
studentnamelist.add(name);
}
}
class Studentnumber {
List
List
public Studentnumber() {
super();
this.studentnumberlist = new ArrayList<>();
this.studentnamelist = new ArrayList<>();
}
public void addstudentnumber(int number) {
studentnumberlist.add(number);
}
public void addstudentname(String name) {
studentnamelist.add(name);
}
}
class Wrongformat {
public Wrongformat() {
}
public boolean Check(String line) {
if (line.matches("(\s#N:\s[0-9]+\s+?#Q:[#]+\s+?#A:[#])\s")||
line.matches("\s#T:\s[0-9]+\s") ||
line.matches("(\s#T:\s[0-9]+\s)(\s+[0-9]+-[0-9]+)+\s")||
line.matches("(\s#S:\s[0-9]+\s+[0-9]+)\s") ||
line.matches("(\s#S:\s[0-9]+\s+?[0-9]+)(\s+#A:\s[0-9]+-\S)+\s")||
line.matches("(\s#X:\s)") ||
line.matches("(\s#X:\s)([0-9]+\s+[^- ]+-)([0-9]+\s+[^- ]+)\s")||
line.matches("\s#D:\s") ||
line.matches("\s#D:\sN-[0-9]+\s")||line.equals("end")) {
return true;
}
else
return false;
}
}
public class Main{
@SuppressWarnings("unused")
public static void main(String[] args){
//@SuppressWarnings("resource")
Scanner input=new Scanner(System.in);
int number = 0;
int numberT = 0;
String problem = null;
String standard = null;
Testpaper testpaper = new Testpaper();
Answerpaper answerpaper = new Answerpaper(testpaper);
Information information = new Information();
Studentnumber studentnumber = new Studentnumber();
Score score = new Score();
Wrongformat wrongformat = new Wrongformat();
int z=0;
int num = 0;
int j1=0;
int [] d = {-1,-1,-1,-1,-1,-1,-1};
int n = 0;
int t = 0;
int errorT[]= {-1,-1,-1,-1,-1,-1,-1};
int errorproblemN[] = {-1,-1,-1,-1,-1,-1,-1};
int question[]= {-1,-1,-1,-1,-1,-1,-1};
int p1=0;
int p2=0;
int S=0;
int studentnum = 0;
String sc1[] = new String[10];
//System.out.println(1);
while (input.hasNextLine()) {
String sc = input.nextLine();
sc1[n] = sc;
if (sc.equals("end")) {
break;
}
String s[]=sc.split("#Q:|#A:|#|:");
if(s[1].equals("N"))
{
if(wrongformat.Check(sc)==false)
{
System.out.println("wrong format:"+sc);
}
String parts[]=sc.split(" ");
if(parts[1].charAt(0)=='#')
{
standard=s[4].trim();
problem=s[3].trim();
number=Integer.parseInt(s[2].trim());
testpaper.addproblem(number, problem, standard);
question[n] = number;
n++;
t++;
}
else
{
String parts1[]=parts[0].split(":");
errorproblemN[p2]=Integer.parseInt(parts1[1].trim());
question[n] = errorproblemN[n];
testpaper.addproblem(errorproblemN[n], "+1=", "2");
p2++;
n++;
t++;
}
//System.out.println(testpaper.problemlist.get(n-1).getContent());
}
else if(s[1].equals("S"))
{
if(wrongformat.Check(sc)==false)
{
System.out.println("wrong format:"+sc);
}
String [] parts = sc.split(" ");
String [] num1 = parts[0].split(":");
numberT = Integer.parseInt(num1[1].trim());
answerpaper.addnumber(numberT);
S=parts.length-2;
int m=2;
int v = Integer.parseInt(parts[1].trim());
studentnumber.addstudentnumber(v);
while(m<parts.length) {
String [] parts1 = parts[m].split(":");
String [] parts2 = parts1[1].split("-");
answerpaper.addAnswernumber(Integer.parseInt(parts2[0]));
answerpaper.addAnswer(parts2[1]);
m++;
}
}
else if (s[1].equals("T")) {
if(wrongformat.Check(sc)==false)
{
System.out.println("wrong format:"+sc);
}
int m=1;
String[] parts = sc.split(" ");
numberT = Integer.parseInt(parts[0].substring(3));
score.addscorenumber(numberT);
while(m<1+t) {
String [] parts1 = parts[m].split("-");
score.addscore(Integer.parseInt(parts1[0]),Integer.parseInt(parts1[1]));
num = num + Integer.parseInt(parts1[1]);
z++;
m++;
}
int p=0;
for(p=0;p<z;p++)
{
int s1=0;
int numm=0;
for(s1=0;s1<z;s1++)
{
if(score.numberlist.get(p)==question[s1])
{
numm=1;
break;
}
}
if(numm==0)
{
errorT[p1]=p;
p1++;
}
}
}
else if(s[1].equals("X")){
if(wrongformat.Check(sc)==false)
{
System.out.print("wrong format:"+sc);
}
String[] parts = sc.split(" ");
studentnum = parts.length-1;
//System.out.println(1000);
String [] parts1 = parts[0].split(":");
information.addstudentnumber(Integer.parseInt(parts1[1]));
for(int i=1;i<parts.length;i++) {
if(i==parts.length-1) {
String [] parts2 = parts[i].split("-");
information.addstudentname(parts2[0]);
}
else
{
String [] parts2 = parts[i].split("-");
information.addstudentname(parts2[0]);
information.addstudentnumber(Integer.parseInt(parts2[1]));
}
}
}
else if(s[1].equals("D")) {
if(wrongformat.Check(sc)==false)
{
System.out.println("wrong format:"+sc);
}
String parts[] = sc.split(":");
String [] parts1 = parts[1].split("-");
//testpaper.removeproblem(Integer.parseInt(parts1[1]));
//n--;
d[j1]=Integer.parseInt(parts1[1]);
j1++;
}
}
// for(int i=0;i<p2;i++)
// {
// for(int k=0;k<n;k++)
// {
// if(errorproblemN[i]question[k])
// {
// System.out.println("wrong format:"+sc1[k]);
// }
// }
// }
// for(int i=0;i<n;i++)
// {
// if(wrongformat.Check(sc1[i])false)
// {
// System.out.println("wrong format:"+sc1[i]);
// }
// }
if(num<100)
System.out.println("alert: full score of test paper1 is not 100 points");
if(answerpaper.numberlist.get(0)2)
{
System.out.println("The test paper number does not exist");
}
else
{
for(int s=0;s<n;s++)
{
//System.out.println(testpaper.problemlist.get(0).getContent());
if(s!=errorT[0]&&question[s]!=d[0]&&question[s]!=errorproblemN[0])
{
System.out.println(testpaper.problemlist.get(s).getContent()+""+answerpaper.answerlist.get(s)+""+answerpaper.judgeAnswer(s));
}
}
for(int s=0;s<n;s++)
{
if(errorproblemN[0]question[s])
{
System.out.println("non-existent question~0");
}
else if(errorT[0]s)
{
System.out.println("non-existent question~0");
}
else if(d[0]question[s])
{
int f = 0;
for(f=0;f<answerpaper.answernumberlist.size();f++)
{
if(question[s]answerpaper.answernumberlist.get(f))
break;
}
if(fanswerpaper.answernumberlist.size())
{
System.out.println("answer is null");
}
else
System.out.println("the question "+d[0]+" invalid~0");
}
}
for(int s=0;s<1;s++)
{
int x=0;
for(x=0;x<studentnum;x++)
{
if((studentnumber.studentnumberlist.get(0)).equals(information.studentnumberlist.get(0)))
break;
}
if(x==studentnum)
{
System.out.print(studentnumber.studentnumberlist.get(0) +" not found");
}
else
{
System.out.print(studentnumber.studentnumberlist.get(0)+" "+information.studentnamelist.get(x)+": ");
int sum=0;
if(answerpaper.judgeAnswer(0)==false)
{
System.out.print(0);
sum=sum+0;
}
else
{
if(d[0]==question[s])
{
System.out.print(0);
sum=sum+0;
}
else
{System.out.print(score.scorelist.get(0));
sum=sum+score.scorelist.get(0);
}
}
if(n-j1>1)
{
if(answerpaper.judgeAnswer(1)==false)
{
System.out.printf(" ");
System.out.print(0);sum=sum+0;
}
else
{
System.out.printf(" ");
System.out.print(score.scorelist.get(1));sum=sum+score.scorelist.get(1);
}
}
else
{
if(t>1)
{
System.out.printf(" ");
System.out.print(0);
}
}
System.out.print("~");
System.out.print(sum);
}
}
}
input.close();
}
}
我的代码总结如下：
总行数(Lines)：519
语句数目(Statements)：309
函数圈复杂度(Function Complexity)：52
以上为这第三次作业的输入和输出格式，我们是在前两次作业的基础上可以增加，一个学生信息来储存学生的学号和姓名的信息内容。
这里我们同样和前面两道题目一样要考虑使用正则表达式来分割题目，并且使用列表来储存内容信息，第三次作业的题目变得更加的灵活了起来，我们要考虑更多的可能性，比如题目被删除，题目没有答案，题目总得分不到100分，不存在当前考生，当前题目每有给出分数等等具体情况，我们要仔细思考这些情况类的关系，设计合理的类来对题目进行解析。我们要梳理好他们之间的关系，这样才不会掉进只是满足了题目样例而不满足于更多题目的情况。
4.总结：
在我自己写代码的过程中，我的bug通常来自三种原因：
1、对题面理解的疏忽，我没有将题目很好的理解就马虎开始做题目，我没有具体理解到题目的深层内涵，我只是为了完成样例而写题目，所以导致我的程序写的一点也不好，最后发现我的程序和题目的意思相差甚远
2、对自己代码架构细节出现问题，我使用错误方法去进行类的书写，我的类的结构并不是很好，我的主方法没有满足只是输入和输出的作用。
3、不小心写错代码，每次都会急于求成，将很多细节疏漏，导致自己的代码问题出现很多都没有能够及时去解决，还是后面花了很多的功夫才去找到问题的根源所在。
由于题目的难度加大，Main里面的main（）变得越来越复杂，圈复杂度也越来越高，Main里面可以加一些其他方法，不是所有工作都放在main（）里面，完全可以加一些其他方法来处理信息，在后面的作业中我更应该去考虑将更多的代码放在不同的类中，而不是仅仅只是放在main函数里面，应该要去合理使用类方法。
二.自己学到了什么
在这三次的pta作业中，我感觉非常非常的艰难，我用了很多时间去写这个作业，但是效果好像并不是太好，反而有点偏离轨道的意思了。
我对于我的类感觉使用的方法并不是很正确，我有一些类的方法用错了，还有就是我的正则表达式用的不是很好，甚至可以说是基本不会。
虽然我看了视频，但是自己还是没有下苦功夫去练习，导致自己的基本功不太扎实，很多正则表达式的方法都不会。希望自己能够在以后的学习中能扎扎实实去学习知识，而不是手刨地，下错功夫。
在这三次作业上，我感觉自己踩了很多坑，但是自己也同时学会了很多。如下：
（1）刚刚开始使用正则表达式来分割题目的时候，老是会分割错误，就是分割得不到自己想要的地方，还有就是自己所需要分割的对象没有搞清楚，这个还是在自己错误了很多次，然后和同学讨论了自己才明白了一点点，所以这个正则表达式要多练习。
（2）刚开始写这道题的时候没有用类，所以违背了他的封装性。
（3）写题目的时候自己不知道如何返回自己的答案true 或者 false，后面仔细看了很久题目才明白了意思（同时也寻求了同学的帮助）。
（4）一旦题目没有按照它的规则来我的程序就是错误的，说明我在写题目的时候仅仅考虑的它的样例，而忽略了它的本质，我没有很好的去研究题目，而只是一味的在研究它的样例，导致我在作后面题目的时候仅仅只是能拿到样例的分数，而其他的测试的根本过不了，所以以后在写题目之前应该认真申请题目，不要一味的只知道看重表面。
（5）自己在写题目的时候，自己忽视了名字的取法，导致自己后续在做题目的过程中非常吃力，应该根本不知道自己这个变量是什么意思，所以以后在写代码的过程中应该更多的去考虑它本身的实际意义，而不是随便取几个变量名。
（6）在后续的作业中，，建议为重要的部分添加注释，以提高代码的可读性和可维护性。
（7）考虑将输入解析和处理的逻辑分离到不同的方法中，以提高代码的可读性和可维护性
（8）如果试卷中的问题和分数数量是不确定的，那么尽量去使用 ArrayList 列表，这个列表可以方便增加和减少数据。
（9）可以将输入处理、问题解析和试卷解析的逻辑分别放在不同的方法中，而不是全放在main（）里面，而main函数尽量只做到输入和输出。
有感而发：通过完成这三次pta的Java编程作业，我加深了对面向对象的理解，学会正则表达式，ArrayList等列表的简单使用，同时了解到了许多java自带的很多方法。
目前我认为我需要进一步学习和研究的地方一是加强面向对象的设计而不是面向过程设计，二就是多了解一些Java方法，三是去了解更多的方法来解题，而不是仅仅依靠自己当前的知识。
题目在不断变化，而我们的代码的类的设计需要有可扩展性，对于类的书写要满足类的特性。