1. 前言
2. 設計與分析
2.1 OOP-1：答題判題程式1
2.1.1 題目
2.1.2 原始碼
2.1.3 評價與分析
2.1.4 踩坑心得
2.1.5 改進建議
2.1 OOP-2：答題判題程式2
2.1.1 題目
2.1.2 原始碼
2.1.3 評價與分析
2.1.4 踩坑心得
2.1.5 改進建議
2.1 OOP-3：答題判題程式3
2.1.1 題目
2.1.2 原始碼
2.1.3 評價與分析
2.1.4 踩坑心得
2.1.5 改進建議
3.總結
1. 前言：
第一階段的學習中，我們主要學習瞭如何利用單一職責原則進行程式設計，以及對於複雜問題的需求分析，類的設計等。並且使用這一系列的知識來進行了三次的PTA作業程式碼編寫。前三次的PTA都是建立在類的設計，正規表示式和單一職責原則的程式設計題目，一次一次類數逐漸上升，難度逐漸上升，類與類的關係逐漸變得複雜。
2. 設計與分析：
2.1 OOP-1：答題判題程式1：
2.1.1 題目：
設計實現答題程式，模擬一個小型的測試，要求輸入題目資訊和答題資訊，根據輸入題目資訊中的標準答案判斷答題的結果。
輸入格式:
程式輸入資訊分三部分：
1.題目數量
格式：整數數值，若超過1位最高位不能為0，
樣例：34
2、題目內容
一行為一道題，可以輸入多行資料。
格式："#N:"+題號+" "+"#Q:"+題目內容+" "#A:"+標準答案
格式約束：題目的輸入順序與題號不相關，不一定按題號順序從小到大輸入。
樣例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
3、答題資訊
答題資訊按行輸入，每一行為一組答案，每組答案包含第2部分所有題目的解題答案，答案的順序號與題目題號相對應。
格式："#A:"+答案內容
格式約束：答案數量與第2部分題目的數量相同，答案之間以英文空格分隔。
樣例：#A:2 #A:78
答題資訊以一行"end"標記結束，"end"之後的資訊忽略。
輸出格式:
1、題目數量
格式：整數數值，若超過1位最高位不能為0，
樣例：34
2、答題資訊
一行為一道題的答題資訊，根據題目的數量輸出多行資料。
格式：題目內容+" ~"+答案
樣例：1+1=~2
2+2= ~4
3、判題資訊
判題資訊為一行資料，一條答題記錄每個答案的判斷結果，答案的先後順序與題目題號相對應。
格式：判題結果+" "+判題結果
格式約束：
1、判題結果輸出只能是true或者false，
2、判題資訊的順序與輸入答題資訊中的順序相同
樣例：true false true
2.1.2原始碼：
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int num=input.nextInt();
String[] list=new String[num];
List<String>testList=new ArrayList<>();
List<Test>tests=new ArrayList<>();
//對於排序的處理
for(int i=0;i<num;i++) {
if(i==0)
input.nextLine();
list[i]=input.nextLine();
String realList[]=list[i].split("#Q:");
String realList2[]=realList[0].split("#N:");
int number=Integer.parseInt(realList2[1].trim());
String[] realList3=(realList[1].split("#A:"));
testList.add(realList2[0].trim());
testList.add(realList3[0].trim());
testList.add(realList3[1].trim());
String content=realList3[0].trim();
String standardAnswer=realList3[1].trim();
Test test=new Test(number,content,standardAnswer);
test.setId(number);
test.setContent(content);
test.setStandardAnswer(standardAnswer);
tests.add(test);
}
for(int i=0;i<num;i++)
{
for(int j=0;j<num-i-1;j++)
{
if(tests.get(j).getId()>tests.get(j+1).getId())
{
Test temp=tests.get(j);
tests.set(j,tests.get(j+1));
tests.set(j+1,temp);
}
}
}
String answer= input.nextLine();
String answerList[]=answer.split("#A:");
{
for(int i=0;i<num;i++)
answerList[i]=answerList[i+1];
}
String[] answerList1=new String[num];
for(int i=0;i<num;i++) {
answerList1[i]=answerList[i].trim();
}
for(int i=0;i<num;i++)
{
System.out.println(tests.get(i).getContent()+"~"+answerList1[i]);
}
for(int i=0;i<num;i++)
{
if(i!=num-1) {
if (tests.get(i).correct(answerList1[i])) {
System.out.print("true ");
} else {
System.out.print("false ");
}
}
else
{
if (tests.get(i).correct(answerList1[i])) {
System.out.print("true");
} else {
System.out.print("false");
}
}
}
String end=input.nextLine();
}
}
class Test
{
private int id;
private String content;
private String standardAnswer;
public Test(int id, String content, String standardAnswer) {
this.id = id;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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 correct(String answer)
{
if(answer.equals(standardAnswer))
{
return true;
}
else
{
return false;
}
}
}
2.1.3評價與分析：
本題的難度不大，重點考察了類與物件的使用和正規表示式。應當有3-4個類。
本題模擬的是單個試卷的資訊處理。
分類的類主函式接受到的資訊分為不同的種類，將他們分別分配為他們自己的類中的資料。
再用函式根據他們的題號來進行排序，
利用函式對答案和起對應的標答是否相同。
依據函式的布林返回值來進行輸出。
2.1.4 踩坑心得：
1、再輸出階段總是會輸出多一行或者少一行，此時應當去迴圈中找問題，例如：迴圈的次數是否是對應的題目數量，是否是對應的輸入的句子的行數。
2、輸入是會出現有部分輸入被吞掉的問題。此時應當再最後一個輸入前加入一個空輸入，清理掉錯誤的程式碼空間，這樣就可以使我們的輸入全部被提取到。
3、分類是用到動態陣列來加入新的資訊，這樣可以解決多資訊無法同時賦值到實體類中的問題。
2.1.5 改進建議：
1、應當用足夠的類來解放死的資料的陣列，做到分類。
2、應當注意再另外類中進行其他類的引用.
2.2 OOP-2-7-4
2.2.1 題目：
設計實現答題程式，模擬一個小型的測試，以下粗體字顯示的是在答題判題程式-1基礎上增補或者修改的內容。
要求輸入題目資訊、試卷資訊和答題資訊，根據輸入題目資訊中的標準答案判斷答題的結果。
輸入格式:
程式輸入資訊分三種，三種資訊可能會打亂順序混合輸入：
1、題目資訊
一行為一道題，可輸入多行資料（多道題）。
格式："#N:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
格式約束：
1、題目的輸入順序與題號不相關，不一定按題號順序從小到大輸入。
2、允許題目編號有缺失，例如：所有輸入的題號為1、2、5，缺少其中的3號題。此種情況視為正常。
樣例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、試卷資訊
一行為一張試卷，可輸入多行資料（多張卷）。
格式："#T:"+試卷號+" "+題目編號+"-"+題目分值
題目編號應與題目資訊中的編號對應。
一行資訊中可有多項題目編號與分值。
樣例：#T:1 3-5 4-8 5-2
3、答卷資訊
答卷資訊按行輸入，每一行為一張答卷的答案，每組答案包含某個試卷資訊中的題目的解題答案，答案的順序與試卷資訊中的題目順序相對應。
格式："#S:"+試卷號+" "+"#A:"+答案內容
格式約束：答案數量可以不等於試卷資訊中題目的數量，沒有答案的題目計0分，多餘的答案直接忽略，答案之間以英文空格分隔。
樣例：#S:1 #A:5 #A:22
1是試卷號
5是1號試卷的順序第1題的題目答案
22是1號試卷的順序第2題的題目答案
答題資訊以一行"end"標記結束，"end"之後的資訊忽略。
輸出格式:
1、試卷總分警示
該部分僅當一張試卷的總分分值不等於100分時作提示之用，試卷依然屬於正常試卷，可用於後面的答題。如果總分等於100分，該部分忽略，不輸出。
格式："alert: full score of test paper"+試卷號+" is not 100 points"
樣例：alert: full score of test paper2 is not 100 points
2、答卷資訊
一行為一道題的答題資訊，根據試卷的題目的數量輸出多行資料。
格式：題目內容+""+答案++""+判題結果（true/false）
約束：如果輸入的答案資訊少於試卷的題目數量，答案的題目要輸"answer is null"
樣例：3+2=5true
4+6=22false.
answer is null
3、判分資訊
判分資訊為一行資料，是一條答題記錄所對應試卷的每道小題的計分以及總分，計分輸出的先後順序與題目題號相對應。
格式：題目得分+" "+....+題目得分+"~"+總分
格式約束：
1、沒有輸入答案的題目計0分
2、判題資訊的順序與輸入答題資訊中的順序相同
樣例：5 8 0~13
根據輸入的答卷的數量以上2、3項答卷資訊與判分資訊將重複輸出。
4、提示錯誤的試卷號
如果答案資訊中試卷的編號找不到，則輸出”the test paper number does not exist”，參見樣例9。
設計建議：
參考答題判題程式-1，建議增加答題類，類的內容以及類之間的關聯自行設計。
2.2.2 原始碼
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
List<String>list=new ArrayList<>();
List<Test>subjects=new ArrayList<>();
List<Paper>allPaper=new ArrayList<>();
List<AnswerList>allAnswer=new ArrayList<>();
List<Integer>grade=new ArrayList<>();
List<Integer>gradeNumber=new ArrayList<>();
List<String>answers=new ArrayList<>();
int num=0;
while(true)
{
String str=input.nextLine();
if(str.contains("end"))
break;
else
{
list.add(str);
num++;
}
}
for(int i=0;i<num;i++)
{
//提取題目
if(list.get(i).contains("#N"))
{
String realList[]=list.get(i).split(" ");
String id[]=realList[0].split("#N:");
int number=Integer.parseInt(id[1].trim());
String contents[]=realList[1].split("#Q:");
String content=contents[1].trim();
String standard[]=realList[2].split("#A:");
String standardAnswer=standard[1].trim();
Test test=new Test(number,content,standardAnswer);
subjects.add(test);
}
else
{
//提取試卷資訊
if(list.get(i).contains("#T"))
{
String realList[]=list.get(i).split(" ");
String id[]=realList[0].split("#T:");
int number=Integer.parseInt(id[1].trim());
for(int j=1;j<realList.length;j++)
{
String subject1[]=realList[j].split("-");
grade.add(Integer.parseInt(subject1[1].trim()));
gradeNumber.add(Integer.parseInt(subject1[0].trim()));
}
Paper paper=new Paper(grade,gradeNumber,number);
allPaper.add(paper);
}
else
{
//提取做答資訊
String realList[]=list.get(i).split(" ");
String id[]=realList[0].split("#S:");
int number=Integer.parseInt(id[1].trim());
for(int j=1;j<realList.length;j++)
{
String answer[]=realList[j].split("#A:");
answers.add(answer[1].trim());
}
AnswerList answerList=new AnswerList(number,answers);
allAnswer.add(answerList);
}
}
}
int count=0;
for(int i=0;i<allPaper.size();i++)
{
for(int j=0;j<allPaper.get(i).getGrade().size();j++)
{
count=count+allPaper.get(i).getGrade().get(j);
}
if(count!=100)
System.out.println("alert: full score of test paper"+allPaper.get(i).getNum()+" is not 100 points");
}
for(int i=0;i<allPaper.size();i++) {
for (int m = 0; m < allAnswer.size(); m++)
{
int score = 0;
if(allAnswer.get(i).getNumber()!=allPaper.get(i).getNum())
System.out.println("The test paper number does not exist");
else {
for (int j = 0; j < allPaper.get(i).getGrade().size(); j++)
if (allAnswer.get(i).getAnswers().get(j+2*m).equals(subjects.get(j).getStandardAnswer())) {
System.out.println(subjects.get(j).getContent() + "~" + allAnswer.get(i).getAnswers().get(j+2*m) + "~" + "true");
score = score + allPaper.get(i).getGrade().get(j);
} else {
if(allAnswer.get(i).getAnswers().get(j+2*m)==null)
System.out.println("answer is null");
else
System.out.println(subjects.get(j).getContent() + "~" + allAnswer.get(i).getAnswers().get(j+2*m) + "~" + "false");
}
for (int j = 0; j < allPaper.get(i).getGrade().size(); j++) {
if (j != allPaper.get(i).getGrade().size() - 1) {
if (allAnswer.get(i).getAnswers().get(j + 2 * m).equals(subjects.get(j).getStandardAnswer())) {
System.out.print(allPaper.get(i).getGrade().get(j) + " ");
} else {
System.out.print("0 ");
}
} else {
if (allAnswer.get(i).getAnswers().get(j + 2 * m).equals(subjects.get(j).getStandardAnswer()))
System.out.println(allPaper.get(i).getGrade().get(j) + "~" + score);
else
System.out.println("0~" + score);
}
}
}
}
}
}
}
class Test
{
private int id;
private String content;
private String standardAnswer;
public Test(int id, String content, String standardAnswer) {
this.id = id;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
}
class Paper
{
private List<Integer>grade=new ArrayList<>();
private List<Integer>number=new ArrayList<>();
private int num;
public Paper(List<Integer> grade, List<Integer> number, int num) {
this.grade = grade;
this.number = number;
this.num = num;
}
public List<Integer> getGrade() {
return grade;
}
public void setGrade(List<Integer> grade) {
this.grade = grade;
}
public List<Integer> getNumber() {
return number;
}
public void setNumber(List<Integer> number) {
this.number = number;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
int ag=0;
public boolean allGrade()
{
for (int i=0;i<number.size();i++)
{
ag=grade.get(i)+ag;
}
if(ag==100)
{
return true;
}
else
{
return false;
}
}
}
class AnswerList
{
private int number;
private List<String>answers=new ArrayList<>();
public AnswerList(int number, List<String> answers) {
this.number = number;
this.answers = answers;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public List<String> getAnswers() {
return answers;
}
public void setAnswers(List<String> answers) {
this.answers = answers;
}
}
2.2.3 設計與分析
本題模擬的是多張試卷和多張答卷的資訊處理。
本題難度較大，新加入答題類以遵循單一職責原則。
需要用分類將資訊分給每一個類中進行方法的判斷，得到結論後再傳遞到下一個類中。
最後傳到輸出中進行輸出。
2.2.4 踩坑心得
1、一定要遵循單一職責原則進行程式的設計，否則會大大得增長程式的執行時間，導致無法在規定的時間完成程式的執行，同時因為大量的判斷句式和for迴圈，在編寫程式的時候很容易出現邏輯問題，且很難進行更改。
2、一定要關注每一個動態陣列的提取的路徑，尤其是用.size來獲取其長度的時候，容易提取到上一級或者下一級的長度從而導致程式出現問題。
2.2.5 改進建議
1、將主函式中的分類和輸出都分別放入一個專門進行分類或者輸出的類中。
2、儘量在每一個函式或者使較為複雜的方法前面加入註釋，那樣即使在編寫程式碼的期間因為一些其他事打斷後也能快速找回思路，繼續完成程式碼的編寫。
3、若在寫完一部分後發現程式碼中少了某些成分，可以新加入新的類來編寫新的方法以避免因為加入新方法導致大量的if語句出現使主要的程式變得冗亂。
2.3 OOP-3-7-3
2.3.1 題目：
設計實現答題程式，模擬一個小型的測試，以下粗體字顯示的是在答題判題程式-2基礎上增補或者修改的內容，要求輸入題目資訊、試卷資訊、答題資訊、學生資訊、刪除題目資訊，根據輸入題目資訊中的標準答案判斷答題的結果。
輸入格式:
程式輸入資訊分五種，資訊可能會打亂順序混合輸入。
1、題目資訊
題目資訊為獨行輸入，一行為一道題，多道題可分多行輸入。
格式："#N:"+題目編號+" "+"#Q:"+題目內容+" "#A:"+標準答案
格式約束：
1、題目的輸入順序與題號不相關，不一定按題號順序從小到大輸入。
2、允許題目編號有缺失，例如：所有輸入的題號為1、2、5，缺少其中的3號題。此種情況視為正常。
樣例：#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
2、試卷資訊
試卷資訊為獨行輸入，一行為一張試卷，多張卷可分多行輸入資料。
格式："#T:"+試卷號+" "+題目編號+"-"+題目分值+" "+題目編號+"-"+題目分值+...
格式約束：
題目編號應與題目資訊中的編號對應。
一行資訊中可有多項題目編號與分值。
樣例：#T:1 3-5 4-8 5-2
3、學生資訊
學生資訊只輸入一行，一行中包括所有學生的資訊，每個學生的資訊包括學號和姓名，格式如下。
格式："#X:"+學號+" "+姓名+"-"+學號+" "+姓名....+"-"+學號+" "+姓名
格式約束：
答案數量可以不等於試卷資訊中題目的數量，沒有答案的題目計0分，多餘的答案直接忽略，答案之間以英文空格分隔。
樣例：
#S:1 #A:5 #A:22
1是試卷號
5是1號試卷的順序第1題的題目答案
4、答卷資訊
答卷資訊按行輸入，每一行為一張答卷的答案，每組答案包含某個試卷資訊中的題目的解題答案，答案的順序號與試 卷資訊中的題目順序相對應。答卷中：
格式："#S:"+試卷號+" "+學號+" "+"#A:"+試卷題目的順序號+"-"+答案內容+...
格式約束：
答案數量可以不等於試卷資訊中題目的數量，沒有答案的題目計0分，多餘的答案直接忽略，答案之間以英文空格分隔。
答案內容可以為空，即””。
答案內容中如果首尾有多餘的空格，應去除後再進行判斷。
樣例：
#T:1 1-5 3-2 2-5 6-9 4-10 7-3
#S:1 20201103 #A:2-5 #A:6-4
1是試卷號
20201103是學號
2-5中的2是試卷中順序號，5是試卷第2題的答案，即T中3-2的答案
6-4中的6是試卷中順序號，4是試卷第6題的答案，即T中7-3的答案
注意：不要混淆順序號與題號
5、刪除題目資訊
刪除題目資訊為獨行輸入，每一行為一條刪除資訊，多條刪除資訊可分多行輸入。該資訊用於刪除一道題目資訊，題目被刪除之後，引用該題目的試卷依然有效，但被刪除的題目將以0分計，同時在輸出答案時，題目內容與答案改為一條失效提示，例如：”the question 2 invalid~0”
格式："#D:N-"+題目號
格式約束：
題目號與第一項”題目資訊”中的題號相對應，不是試卷中的題目順序號。
本題暫不考慮刪除的題號不存在的情況。
樣例：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#X:20201103 Tom-20201104 Jack
#S:1 20201103 #A:1-5 #A:2-4
#D:N-2
end
輸出
alert: full score of test paper1 is not 100 points
1+1=~5~false
the question 2 invalid~0
20201103 Tom: 0 0~0
答題資訊以一行"end"標記結束，"end"之後的資訊忽略。
輸出格式:
1、試卷總分警示
該部分僅當一張試卷的總分分值不等於100分時作提示之用，試卷依然屬於正常試卷，可用於後面的答題。如果總分等於100 分，該部分忽略，不輸出。
格式："alert: full score of test paper"+試卷號+" is not 100 points"
樣例：alert: full score of test paper2 is not 100 points
2、答卷資訊
一行為一道題的答題資訊，根據試卷的題目的數量輸出多行資料。
格式：題目內容+""+答案++""+判題結果（true/false）
約束：如果輸入的答案資訊少於試卷的題目數量，每一個缺失答案的題目都要輸出"answer is null" 。
樣例：
3+2=~5~true
4+6=~22~false.
answer is null
3、判分資訊
判分資訊為一行資料，是一條答題記錄所對應試卷的每道小題的計分以及總分，計分輸出的先後順序與題目題號相對應。
格式：學號+" "+姓名+": "+題目得分+" "+....+題目得分+"~"+總分
格式約束：
1、沒有輸入答案的題目、被刪除的題目、答案錯誤的題目計0分
2、判題資訊的順序與輸入答題資訊中的順序相同
樣例：20201103 Tom: 0 0~0
根據輸入的答卷的數量以上2、3項答卷資訊與判分資訊將重複輸出。
4、被刪除的題目提示資訊
當某題目被試卷引用，同時被刪除時，答案中輸出提示資訊。樣例見第5種輸入資訊“刪除題目資訊”。
5、題目引用錯誤提示資訊
試卷錯誤地引用了一道不存在題號的試題，在輸出學生答案時，提示”non-existent question~”加答案。例如：
輸入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103 #A:1-4
end
輸出：
alert: full score of test paper1 is not 100 points
non-existent question~0
20201103 Tom: 0~0
如果答案輸出時，一道題目同時出現答案不存在、引用錯誤題號、題目被刪除，只提示一種資訊，答案不存在的優先順序最高，例如：
輸入：
#N:1 #Q:1+1= #A:2
#T:1 3-8
#X:20201103 Tom-20201104 Jack-20201105 Www
#S:1 20201103
end
輸出：
alert: full score of test paper1 is not 100 points
answer is null
20201103 Tom: 0~0
6、格式錯誤提示資訊
輸入資訊只要不符合格式要求，均輸出”wrong format:”+資訊內容。
例如：wrong format:2 #Q:2+2= #4
7、試卷號引用錯誤提示輸出
如果答卷資訊中試卷的編號找不到，則輸出”the test paper number does not exist”，答卷中的答案不用輸出，參見樣例8。
8、學號引用錯誤提示資訊
如果答卷中的學號資訊不在學生列表中，答案照常輸出，判分時提示錯誤。參見樣例9。
本題暫不考慮出現多張答卷的資訊的情況。
2.3.2 原始碼：
import java.util.List;
import java.util.Scanner;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
List<String>list=new ArrayList<>();
while(true)
{
String str=input.nextLine();
if(str.contains("end"))
break;
else
{
list.add(str);
}
}
Range range=new Range(list);
range.chess();
range.select();
range.clean();
Agent1 agent1=new Agent1(range);
Agent2 agent2=new Agent2(range);
Agent3 agent3=new Agent3(range);
PrintOut printout=new PrintOut(agent1,agent2,agent3,range);
printout.print();
}
}
class Range {
private List<Subject> subjects = new ArrayList<>();
private List<Paper> papers = new ArrayList<>();
private List<AnswerList> answerLists = new ArrayList<>();
private List<Student> students = new ArrayList<>();
private List<Delete> deletes = new ArrayList<>();
private List<String> information;
public Range(List<String> information) {
this.information = information;
}
public List<Subject> getSubjects() {
return subjects;
}
public void setSubjects(List<Subject> subjects) {
this.subjects = subjects;
}
public List<Paper> getPapers() {
return papers;
}
public void setPapers(List<Paper> papers) {
this.papers = papers;
}
public List<AnswerList> getAnswerLists() {
return answerLists;
}
public void setAnswerLists(List<AnswerList> answerLists) {
this.answerLists = answerLists;
}
public List<Student> getStudents() {
return students;
}
public void setStudents(List<Student> students) {
this.students = students;
}
public List<Delete> getDeletes() {
return deletes;
}
public void setDeletes(List<Delete> deletes) {
this.deletes = deletes;
}
public List<String> getInformation() {
return information;
}
public void setInformation(List<String> information) {
this.information = information;
}
public void select() {
for (int i = 0; i < information.size(); i++) {
if (information.get(i).contains("#N")) {
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#N:");
int Id = Integer.parseInt(inform1[1].trim());
String inform2[] = informs[1].split("#Q:");
String Content = inform2[1].trim();
String inform3[] = informs[2].split("#A:");
String StandardAnswer = (inform3[1].trim());
Subject subject = new Subject(Id, Content, StandardAnswer);
subjects.add(subject);
} else {
if (information.get(i).contains("#T")) {
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#T:");
int paperId = (Integer.parseInt(inform1[1].trim()));
List<Integer> num = new ArrayList<>();
List<Integer> grade = new ArrayList<>();
for (int j = 1; j < informs.length; j++) {
String inform2[] = informs[j].split("-");
num.add(Integer.parseInt(inform2[0]));
grade.add(Integer.parseInt(inform2[1]));
}
Paper paper = new Paper(paperId, num, grade);
papers.add(paper);
} else {
if (information.get(i).contains("#X")) {
List<Integer> id = new ArrayList<>();
List<String> name = new ArrayList<>();
String informs[] = information.get(i).split("-");
String inform[] = informs[0].split("#X:");
String inform2[] = inform[1].split(" ");
id.add(Integer.parseInt(inform2[0].trim()));
name.add(inform2[1].trim());
for (int j = 1; j < informs.length; j++) {
String inform1[] = informs[j].split(" ");
id.add(Integer.parseInt(inform1[0].trim()));
name.add(inform1[1].trim());
}
Student student = new Student(id, name);
students.add(student);
} else {
if (information.get(i).contains("#S")) {
List<Integer> num = new ArrayList<>();
List<String> answer = new ArrayList<>();
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#S:");
int paperId = (Integer.parseInt(inform1[1].trim()));
int studentId = (Integer.parseInt(informs[1].trim()));
for (int j = 2; j < informs.length; j++) {
String inform2[] = informs[j].split("#A:");
String inform3[] = inform2[1].split("-");
num.add(Integer.parseInt(inform3[0].trim()));
answer.add(inform3[1].trim());
}
AnswerList answerList = new AnswerList(paperId, studentId, num, answer);
answerLists.add(answerList);
} else {
String informs[] = information.get(i).split("#D:");
String inform[] = informs[1].split("-");
int subjectId = (Integer.parseInt(inform[1].trim()));
Delete delete = new Delete(subjectId);
deletes.add(delete);
}
}
}
}
}
}
public int chess() {
int id=-1;
for (int i = 0; i < information.size(); i++) {
if (!information.get(i).contains("#Q:") && information.get(i).contains("#N")) {
System.out.println("wrong format:" + information.get(i));
String informs[] = information.get(i).split(" ");
String inform1[] = informs[0].split("#N:");
id = Integer.parseInt(inform1[1].trim());
information.remove(i);
}
}
return id;
}
public void clean()
{
int len=papers.get(0).getSubjectId().size();
for(int i=0;i<len;i++) {
if (papers.get(0).getSubjectId().get(i) == chess())
{
papers.get(0).getSubjectId().remove(i);
papers.get(0).getSubjectGrade().remove(i);
}
}
}
}
class Student
{
private List<Integer>id=new ArrayList<>();
private List<String>name=new ArrayList<>();
public Student(List<Integer> id, List<String> name) {
this.id = id;
this.name = name;
}
public List<Integer> getId() {
return id;
}
public void setId(List<Integer> id) {
this.id = id;
}
public List<String> getName() {
return name;
}
public void setName(List<String> name) {
this.name = name;
}
}
class Paper
{
private int paperId;
private List<Integer>subjectId=new ArrayList<>();
private List<Integer>subjectGrade=new ArrayList<>();
public Paper(int paperId, List<Integer> subjectId, List<Integer> subjectGrade) {
this.paperId = paperId;
this.subjectId = subjectId;
this.subjectGrade = subjectGrade;
}
public int getPaperId() {
return paperId;
}
public void setPaperId(int paperId) {
this.paperId = paperId;
}
public List<Integer> getSubjectId() {
return subjectId;
}
public void setSubjectId(List<Integer> subjectId) {
this.subjectId = subjectId;
}
public List<Integer> getSubjectGrade() {
return subjectGrade;
}
public void setSubjectGrade(List<Integer> subjectGrade) {
this.subjectGrade = subjectGrade;
}
}
class Subject
{
private int subjectId;
private String content;
private String standardAnswer;
public Subject(int subjectId, String content, String standardAnswer) {
this.subjectId = subjectId;
this.content = content;
this.standardAnswer = standardAnswer;
}
public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
}
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;
}
}
class AnswerList
{
private int paperId;
private int studentId;
private List<Integer>subjectId;
private List<String>answer;
public AnswerList(int paperId, int studentId, List<Integer> subjectId, List<String> answer) {
this.paperId = paperId;
this.studentId = studentId;
this.subjectId = subjectId;
this.answer = answer;
}
public int getPaperId() {
return paperId;
}
public void setPaperId(int paperId) {
this.paperId = paperId;
}
public int getStudentId() {
return studentId;
}
public void setStudentId(int studentId) {
this.studentId = studentId;
}
public List<Integer> getSubjectId() {
return subjectId;
}
public void setSubjectId(List<Integer> subjectId) {
this.subjectId = subjectId;
}
public List<String> getAnswer() {
return answer;
}
public void setAnswer(List<String> answer) {
this.answer = answer;
}
}
class Delete
{
private int subjectId;
public Delete(int subjectId) {
this.subjectId = subjectId;
}
public int getSubjectId() {
return subjectId;
}
public void setSubjectId(int subjectId) {
this.subjectId = subjectId;
}
}
class Agent1
{
private Range range;
public Agent1(Range range) {
this.range = range;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
int sum=0;
//計算總分並判斷其是否為100
public boolean sum()
{
for(int i=0;i<range.getPapers().get(0).getSubjectGrade().size();i++)
{
sum=sum+range.getPapers().get(0).getPaperId();
}
if(sum==100)
{
return true;
}
else
{
return false;
}
}
}
class Agent2
{
private Range range;
public Agent2(Range range) {
this.range = range;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
//判斷答案是否正確
public boolean[] correct()
{
int n=0;
boolean[] result=new boolean[range.getAnswerLists().get(0).getAnswer().size()];
for(int i=0;i<range.getAnswerLists().get(0).getAnswer().size();i++)
{
for(int j=0;j<range.getSubjects().size();j++)
{
if(range.getAnswerLists().get(0).getSubjectId().get(i).equals(range.getSubjects().get(j).getSubjectId()))
{
if(range.getAnswerLists().get(0).getAnswer().get(i).equals(range.getSubjects().get(j).getStandardAnswer()))
result[i]=true;
else
result[i]=false;
}
}
}
return result;
}
//比較答案的數量，以確定答案是否存在
public boolean compare()
{
if(range.getAnswerLists().get(0).getAnswer().size()>=range.getSubjects().size())
return true;
else
return false;
}
//判斷答案是否有對應的題目
public boolean[] mate()
{
int n=0;
boolean[] result=new boolean[range.getAnswerLists().get(0).getAnswer().size()];
for(int i=0;i<range.getAnswerLists().get(0).getAnswer().size();i++)
{
for(int j=0;j<range.getPapers().get(0).getSubjectId().size();j++)
{
if(!range.getDeletes().isEmpty()) {
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getPapers().get(0).getSubjectId().get(j) || range.getAnswerLists().get(0).getSubjectId().get(i) != range.getDeletes().get(0).getSubjectId())
n++;
}
else
{
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getPapers().get(0).getSubjectId().get(j))
n++;
}
}
if(n==1)
result[i]=true;
else
result[i]=false;
}
return result;
}
//給分
public int[] giveGrade()
{
int[] grade=new int[range.getAnswerLists().get(0).getAnswer().size()];
for(int i=0;i<range.getAnswerLists().get(0).getAnswer().size();i++)
{
if(!compare())
{
grade[i]=0;
}
else
{
if(range.getAnswerLists().get(0).getSubjectId().get(i)==range.getDeletes().get(0).getSubjectId())
{
grade[i]=0;
}
else
{
if(!mate()[i])
grade[i]=0;
else
{
if(correct()[i])
grade[i]=range.getPapers().get(0).getSubjectGrade().get(i);
else
grade[i]=0;
}
}
}
}
return grade;
}
//被刪除給零分
public void deleted()
{
System.out.println("the question "+range.getDeletes().get(0).getSubjectId()+" invalid~0");
}
}
class Agent3
{
private Range range;
public Agent3(Range range) {
this.range = range;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
//無效的學號引用
public boolean idEffective()
{
int n=0;
for(int i=0;i<range.getStudents().get(0).getId().size();i++)
{
if(range.getAnswerLists().get(0).getStudentId()==range.getStudents().get(0).getId().get(i))
n++;
}
if(n==1)
return true;
else
return false;
}
}
class PrintOut
{
Agent1 agent1;
Agent2 agent2;
Agent3 agent3;
Range range;
public PrintOut(Agent1 agent1, Agent2 agent2, Agent3 agent3, Range range) {
this.agent1 = agent1;
this.agent2 = agent2;
this.agent3 = agent3;
this.range = range;
}
public Agent1 getAgent1() {
return agent1;
}
public void setAgent1(Agent1 agent1) {
this.agent1 = agent1;
}
public Agent2 getAgent2() {
return agent2;
}
public void setAgent2(Agent2 agent2) {
this.agent2 = agent2;
}
public Agent3 getAgent3() {
return agent3;
}
public void setAgent3(Agent3 agent3) {
this.agent3 = agent3;
}
public Range getRange() {
return range;
}
public void setRange(Range range) {
this.range = range;
}
//
public void print() {
int sum = 0;
if (!agent1.sum())
System.out.println("alert: full score of test paper1 is not 100 points");
for (int i = 0; i < range.getPapers().get(0).getSubjectId().size(); i++) {
if (agent2.compare()) {
if(range.getDeletes().size()>0) {
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getDeletes().get(0).getSubjectId()) {
agent2.deleted();
} else {
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
} else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
}
} else {
System.out.println("non-existent question~0");
}
}
}
else
{
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
} else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
}
} else {
System.out.println("non-existent question~0");
}
}
} else {
if (range.getDeletes().size() > 0)
{
if (range.getAnswerLists().get(0).getSubjectId().get(i) == range.getDeletes().get(0).getSubjectId()) {
agent2.deleted();
} else {
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
} else {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
}
} else {
System.out.println("non-existent question~0");
}
}
}
else
{
if (agent2.mate()[i]) {
if (agent2.correct()[i]) {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~true");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
} else {
if (agent2.compare())
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
else {
System.out.println(range.getSubjects().get(range.getAnswerLists().get(0).getSubjectId().get(i) - 1).getContent() + "~" + range.getAnswerLists().get(0).getAnswer().get(i) + "~false");
for (int j = 0; j < range.getSubjects().size() - range.getAnswerLists().get(0).getAnswer().size(); j++) {
System.out.println("answer is null");
}
}
}
} else {
System.out.println("non-existent question~0");
}
}
}
}
if (range.getAnswerLists().get(0).getSubjectId().size() <= range.getStudents().get(0).getName().size()) {
for (int i = 0; i < range.getAnswerLists().get(0).getSubjectId().size()- range.getDeletes().size(); i++) {
if (range.getAnswerLists().get(0).getStudentId() == range.getStudents().get(0).getId().get(i)) {
System.out.print(range.getAnswerLists().get(0).getStudentId() + " " + range.getStudents().get(0).getName().get(i) + ": ");
for (int j = 0; j < range.getPapers().get(0).getSubjectId().size(); j++) {
if (agent2.mate()[j]) {
if (agent2.correct()[j]) {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + " ");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
} else {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + "~");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
}
}
System.out.println(sum);
}
}
else
{
for (int i = 0; i < range.getStudents().get(0).getName().size()-range.getDeletes().size(); i++) {
if (range.getAnswerLists().get(0).getStudentId() == range.getStudents().get(0).getId().get(i)) {
System.out.print(range.getAnswerLists().get(0).getStudentId() + " " + range.getStudents().get(0).getName().get(i) + ": ");
for (int j = 0; j < range.getPapers().get(0).getSubjectId().size(); j++) {
if (agent2.mate()[j]) {
if (agent2.correct()[j]) {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + " ");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
} else {
System.out.print(range.getPapers().get(0).getSubjectGrade().get(j) + "~");
sum = sum + range.getPapers().get(0).getSubjectGrade().get(j);
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
} else {
if (j != range.getPapers().get(0).getSubjectId().size() - 1) {
System.out.print("0 ");
sum = sum + 0;
} else {
System.out.print("0~");
sum = sum + 0;
}
}
}
}
System.out.println(sum);
}
}
}
}
本題目難度較大，需要使用6-11個類完成。
從主函式接收到的輸入資訊，透過分類的類進行分類，將每一種資訊都存入以對應類為元素的動態陣列中，多個控制類再透過這些動態陣列來使對應方法進行下去，達到目的，得到最終的結果，由輸出的類進行接收並輸出。
2.3.4 踩坑心得：
1、輸出類同主函式一樣不要加入太多的程式碼，更多都依賴控制類中的方法。提前在控制類中將各類判斷的方法先寫好，再在輸出類中引用，可以降低程式碼的複雜度，也可以提高正確率。
2、因為資訊中部分的資訊（如題目資訊）可能會有多個，導致我們無法將提取的資料轉到類中儲存。因此需要用到以對應類為元素的動態陣列來儲存這些資訊。呼叫資訊時都提取那些動態陣列中的內容，對動態陣列中的資料進行加工。
3、一定畫完類圖再進行程式碼的編寫。
2.3.5 改進建議
1、需要減少輸出類的長度，將更多的判斷都放到各個控制類之中，使輸出類更精簡。
2、理清每一個方法中迴圈究竟是以什麼陣列的長度來作為迴圈的長度，同時理清每一個方法的整體脈絡，以避免判斷句式出現問題。
3. 總結：
這三次PTA作業的核心都是單一職責原則，要求我們以此原則進行程式的設計。而我也在一次次PTA任務中逐漸完善了我的設計，為接下來第二階段的PTA打下基礎，也會為了完成PTA去學習一些常用的技巧和方法（如正規表示式）。同時我也需要在接下來的學習中加強對於類間關係的梳理和研究學習。遇到問題解決問題。