南昌航空大學23201421-PTA1~3次大作業

23201421-孙彬發表於2024-04-21

一．前言：
這個學期才開始接觸java，到現在一個多月的時間，已經差不多可以寫出一些基本的簡單的程式了。對比上個學期學習的C語言，我認為java更加方便，方法更多，函式更多，但是時間效率上略遜一籌。在這一個月的java學習過程中，剛開始起步很困難，總是想不出來java應該怎麼寫，用之前寫C語言的思路來寫java，雖然大相徑庭，但是還是沒有領悟到“物件導向”的真諦。現在我已經略有領悟，期待未來可以熟練掌握java的日子！
Pta作業已經寫了三次，從第一次的作業開始，最後一題的難度就非常大，涉及的知識面也非常廣，需要自學的內容比較多，而時間也相對於上學期c語言的pta要緊，導致剛開始並沒有很好的適應本學期Java課的作業量與難度，作業也經常難以完成，只能做到完成前面的相對而言較為簡單的題目，但是得分因此非常低，最後一題也從沒真正完成過，想著能得多少分得多少分。總體來說，前三次pta的主要知識點還是在認識java的語言，學會使用類，分割字串，比較以及對某一字串的識別以及用物件導向的思維方式。第一次pta作業主要是讓我們學習部分java語言，畢竟之前都是c語言，課設也是c語言+ege，對完全沒有接觸過java語言的我們還是很有挑戰的。後面兩次pta作業雖然題量不多，但是難度很大，有很多類的呼叫，十分複雜，還需要使用很多函式，對我們來說確實十分困難。
二．設計與分析：
第一次題目集最後一題：
設計實現答題程式，模擬一個小型的測試，要求輸入題目資訊和答題資訊，根據輸入題目資訊中的標準答案判斷答題的結果。
輸入格式:
程式輸入資訊分三部分：

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
2是題號為1的題目的答案
78是題號為2的題目的答案
答題資訊以一行"end"標記結束，"end"之後的資訊忽略。
輸出格式:
1、題目數量
格式：整數數值，若超過1位最高位不能為0，
樣例：34
2、答題資訊
一行為一道題的答題資訊，根據題目的數量輸出多行資料。
格式：題目內容+" ~"+答案
樣例：1+1=~2
2+2= ~4
3、判題資訊
判題資訊為一行資料，一條答題記錄每個答案的判斷結果，答案的先後順序與題目題號相對應。
格式：判題結果+" "+判題結果
格式約束：
1、判題結果輸出只能是true或者false，
2、判題資訊的順序與輸入答題資訊中的順序相同
樣例：true false true
輸入樣例1:
單個題目。例如：
解釋
1

N:1 #Q:1+1= #A:2

A:2

end
輸出樣例1:
在這裡給出相應的輸出。例如：
1+1=~2
true
輸入樣例2:
單個題目。例如：
解釋
1

N:1 #Q:1+1= #A:2

A:4

end
輸出樣例2:
在這裡給出相應的輸出。例如：
1+1=~4
false
輸入樣例3:
多個題目。例如：
解釋
2

N:1 #Q:1+1= #A:2

N:2 #Q:2+2= #A:4

A:2 #A:4

end
輸出樣例3:
在這裡給出相應的輸出。例如：
1+1=~2
2+2=~4
true true
輸入樣例4:
多個題目。例如：
解釋
2

N:1 #Q:1+1= #A:2

N:2 #Q:2+2= #A:4

A:2 #A:2

end
輸出樣例4:
在這裡給出相應的輸出。例如：
1+1=~2
2+2=~2
true false
輸入樣例5:
多個題目，題號順序與輸入順序不同。例如：
解釋
2

N:2 #Q:1+1= #A:2

N:1 #Q:5+5= #A:10

A:10 #A:2

end
輸出樣例5:
在這裡給出相應的輸出。例如：
5+5=~10
1+1=~2
true true
輸入樣例6:
含多餘的空格符。例如：
解釋
1

N:1 #Q: The starting point of the Long March is #A:ruijin

A:ruijin

end
輸出樣例6:
在這裡給出相應的輸出。例如：
The starting point of the Long March is~ruijin
true

輸入樣例7:
含多餘的空格符。例如：
解釋
1

N: 1 #Q: 5 +5= #A:10

A:10

end
輸出樣例7:
在這裡給出相應的輸出。例如：
5 +5=~10
true
程式碼如下：
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

    int questionCount = Integer.parseInt(scanner.nextLine());
    ExamPaper examPaper = new ExamPaper();


    for (int i = 0; i < questionCount; i++) {
        String line = scanner.nextLine();
        String[] parts = line.split(":");
        parts[1]=parts[1].substring(0, parts[1].length() - 2);
        parts[2]=parts[2].substring(0, parts[2].length() - 2);
        // parts[3]=parts[3].substring(0, parts[3].length() - 2);
        parts[1]=parts[1].trim();
        parts[2]=parts[2].trim();
        // parts[3]=parts[3].trim();
        int number = Integer.parseInt(parts[1].substring(0));
        String content = parts[2].substring(0);
        String standardAnswer = parts[3].substring(0);

// System.out.println(number);
// System.out.println(content);
// System.out.println(standardAnswer);
examPaper.saveQuestion(number, content, standardAnswer);
}

    AnswerSheet answerSheet = new AnswerSheet(examPaper);

    while (true) {
        String line = scanner.nextLine();
        if (line.equals("end")) {
            break;
        }
        String[] answers = line.split(" ");
        for (int i = 0; i < answers.length; i++) {
            answerSheet.saveAnswer(i + 1, answers[i].substring(3));
        }
    }

    for (int i = 1; i <=questionCount; i++) {
        answerSheet.output(i);
    }
    if(questionCount==1){
        answerSheet.printResults1();
    }

    //answerSheet.printResults2();
    else{
        answerSheet.printResults2();
    }
}

}
class Question {
private int number;
private String content;
private String standardAnswer;

public Question(int number, String content, String standardAnswer) {
    this.number = number;
    this.content = content;
    this.standardAnswer = standardAnswer;
}
public int getNumber() {
    return number;
}
public String getContent() {
    return content;
}
public String getStandardAnswer() {
    return standardAnswer;
}
public boolean checkAnswer(String answer) {
    return answer.equals(standardAnswer);
}

}
class ExamPaper {
private List questionList = new ArrayList<>();

public void saveQuestion(int number, String content, String standardAnswer) {
    Question question = new Question(number, content, standardAnswer);
    questionList.add(question);
}

public boolean checkAnswer(int number, String answer) {
    return questionList.get(number - 1).checkAnswer(answer);
}

public List<Question> getQuestionList() {
    return questionList;
}

}

class AnswerSheet {
private ExamPaper examPaper;
private List answerList = new ArrayList<>();
private List result = new ArrayList<>();

public AnswerSheet(ExamPaper examPaper) {
    this.examPaper = examPaper;
}

public void saveAnswer(int number, String answer) {
    answerList.add(answer);
    result.add(examPaper.checkAnswer(number, answer));
}

public void output(int number) {
    //int i=0;
    Question question = examPaper.getQuestionList().get(number - 1);
    System.out.println(question.getContent() + "~" + answerList.get(number-1));
}

public void printResults1() {
    for (boolean res : result) {
        System.out.print(res);
    }
}
public void printResults2() {
    int count=0;
    for (boolean res : result) {
        System.out.print(res );
        if(count!=result.size()-1) {
            System.out.print(" ");
        }
        count++;
    }
}

}

設計建議:
以下是針對以上題目要求的設計建議，其中的屬性、方法為最小集，實現程式碼中可根據情況新增所需的內容：
題目類（用於封裝單個題目的資訊）：
屬性：題目編號、題目內容、標準答案-standardAnswer
方法：資料讀寫set\get方法、
判題方法(答案-answer）：判斷答案-answer是否符合標準答案-standardAnswer
試卷類（用於封裝整套題目的資訊）
屬性：題目列表(題目類的物件集合)、題目數量
方法：判題方法(題號-num、答案-answer）：判斷答案-answer是否符合對應題號的題目標準答案-standardAnswer
儲存題目(題號-num、題目-question）：將題目儲存到題目列表中，儲存位置與num要能對應
答卷類（用於封裝答題資訊）
解釋
屬性：試卷（試卷類的物件）、答案列表（儲存每一題的答案）、判題列表（儲存每一題的判題結果true/false）
方法：判題方法(題號-num）：判斷答案列表中第num題的結果是否符合試卷中對應題號的題目標準答案
輸出方法(題號-num）：按照題目的格式要求，輸出題號為num的題目的內容和答題結果。
儲存一個答案(題號-num,答案-answer)：儲存題號為num的題目的答題結果answer。

第二次題目集最後一題：
設計實現答題程式，模擬一個小型的測試，以下粗體字顯示的是在答題判題程式-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=₅true
4+6=₂₂false.
answer is null
3、判分資訊
判分資訊為一行資料，是一條答題記錄所對應試卷的每道小題的計分以及總分，計分輸出的先後順序與題目題號相對應。
格式：題目得分+" "+....+題目得分+"~"+總分
格式約束：
1、沒有輸入答案的題目計0分

N:3 #Q:3+2= #A:5

S:1 #A:5 #A:4

end
輸出樣例:
在這裡給出相應的輸出。例如：
1+1=₅false
2+2=₄true
0 30~30
輸入樣例4:
試卷題目的順序與題號不一致。例如：
解釋

N:1 #Q:1+1= #A:2

N:2 #Q:2+2= #A:4

T:1 2-70 1-30

N:3 #Q:3+2= #A:5

S:1 #A:5 #A:22

N:3 #Q:3+2= #A:5

N:2 #Q:2+2= #A:4

T:1 3-7 2-6

S:1 #A:5 #A:22

N:1 #Q:1+1= #A:2

T:2 2-5 1-3 3-2

S:2 #A:5 #A:4

end
輸出樣例:
在這裡給出相應的輸出。例如：
解釋
alert: full score of test paper1 is not 100 points
alert: full score of test paper2 is not 100 points
3+2=₅true
2+2=₂₂false
7 0~7
2+2=₅false
1+1=₄false
answer is null
0 0 0~0
輸入樣例9:
亂序輸入+分值不足100+兩份答卷+無效的試卷號。例如：
解釋

N:3 #Q:3+2= #A:5

N:2 #Q:2+2= #A:4

T:1 3-7 2-6

S:3 #A:5 #A:4

end
輸出樣例:
在這裡給出相應的輸出。例如：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
程式碼如下：
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input;
int testnum = 0;
int papernum = 0;
int answernum = 0;
Test[] quiz = new Test[5];
Paper[] paper = new Paper[2];
Answer[] answer = new Answer[5];
while (true) {
input = scanner.nextLine();
if (input.equals("end")) {
scanner.close();
break;
} else {
int k = sort(input);
switch (k) {
case 1:
String[] test = f1(input);
quiz[testnum] = new Test(test[0], test[1], test[2]);
testnum++;
break;
case 2:
int[] a = f2(input);
paper[papernum] = new Paper(Integer.toString(a[0]), Integer.toString(a[1]), a[2], Integer.toString(a[3]), a[4], a[2] + a[4]);
papernum++;
break;
case 3:
String[] b = f3(input);
answer[answernum] = new Answer(b[0], b[1], b[2]);
answernum++;
break;
}
}
}
for (int i = 0; i < papernum; i++) {
if (paper[i].getTotalscore() != 100) {
System.out.println("alert: full score of test paper" + paper[i].getNum() + " is not 100 points");
}
}
for (int i = 0; i < answernum; i++) {
if (Integer.parseInt(answer[i].getNum()) > papernum) {
System.out.println("The test paper number does not exist");
} else {
String num1 = paper[i].getTest1();
String num2 = paper[i].getTest2();
int score = 0;
int score1 = 0;
int score2 = 0;
for (int j = 0; j < testnum; j++) {
if (quiz[j].getNum().equals(num1)) {
if (answer[i].getAnswer1().equals(quiz[j].getAnswer())) {
score1 = paper[i].getScore1();
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer1() + "~true");
} else {
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer1() + "~false");
}
break;
}
}
for (int j = 0; j < testnum; j++) {
if (quiz[j].getNum().equals(num2)) {
if (answer[i].getAnswer2().equals(quiz[j].getAnswer())) {
score2 = paper[i].getScore2();
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer2() + "~true");
} else {
System.out.println(quiz[j].getQuestion() + "~" + answer[i].getAnswer2() + "~false");
}
break;
}
}
score = score1 + score2;
answer[i].setUntimatescore(score);
System.out.println(score1 + " " + score2 + "~" + score );
}
}
}

public static int sort(String input) {
    String regex1 = "#N:(\\d+)\\s*#Q:\\s*([^\\s]+)=\\s*#A:\\s*([^\\s]+)";
    String regex2 = "#T:(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)";
    String regex3 = "#S:(\\d+)\\s*#A:(\\d+)\\s*#A:(\\d+)";
    if (input.matches(regex1)) {
        return 1;
    } else if (input.matches(regex2)) {
        return 2;
    } else if (input.matches(regex3)) {
        return 3;
    }
    return 0;
}

public static String[] f1(String input) {
    String regex = "#N:(\\d+)\\s*#Q:\\s*([^\\s]+=)\\s*#A:\\s*([^\\s]+)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);
    String[] array = new String[3];
    if (matcher.matches()) {
        array[0] = matcher.group(1);
        array[1] = matcher.group(2);
        array[2] = matcher.group(3);
    }
    return array;
}

public static int[] f2(String input) {
    String regex = "#T:(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);
    int[] array = new int[5];
    if (matcher.matches()) {
        array[0] = Integer.parseInt(matcher.group(1));
        array[1] = Integer.parseInt(matcher.group(2));
        array[2] = Integer.parseInt(matcher.group(3));
        array[3] = Integer.parseInt(matcher.group(4));
        array[4] = Integer.parseInt(matcher.group(5));
    }
    return array;
}

public static String[] f3(String input) {
    String regex = "#S:(\\d+)\\s*#A:(\\d+)\\s*#A:(\\d+)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);
    String[] array = new String[3];
    if (matcher.matches()) {
        array[0] = matcher.group(1);
        array[1] = matcher.group(2);
        array[2] = matcher.group(3);
    }
    return array;
}

public static int[] f4(String input) {
    String regex = "#T:(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)\\s+(\\d+)-(\\d+)";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);
    int[] array = new int[7];
    if (matcher.matches()) {
        array[0] = Integer.parseInt(matcher.group(1));
        array[1] = Integer.parseInt(matcher.group(2));
        array[2] = Integer.parseInt(matcher.group(3));
        array[3] = Integer.parseInt(matcher.group(4));
        array[4] = Integer.parseInt(matcher.group(5));
        array[5] = Integer.parseInt(matcher.group(6));
        array[6] = Integer.parseInt(matcher.group(7));
    }
    return array;
}

}

class Test {
private String num;
private String question;
private String answer;
public Test() {
}
public Test(String num, String question, String answer) {
this.num = num;
this.question = question;
this.answer = answer;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getQuestion() {
return question;
}
public void setQuestion(String question) {
this.question = question;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String answer) {
this.answer = answer;
}
}
class Paper {
private String num;
private String test1;
private int score1;
private String test2;
private int score2;
private int totalscore;
public Paper() {
}
public Paper(String num, String test1, int score1, String test2, int score2, int totalscore) {
this.num = num;
this.test1 = test1;
this.score1 = score1;
this.test2 = test2;
this.score2 = score2;
this.totalscore = totalscore;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getTest1() {
return test1;
}
public void setTest1(String test1) {
this.test1 = test1;
}
public int getScore1() {
return score1;
}
public void setScore1(int score1) {
this.score1 = score1;
}
public String getTest2() {
return test2;
}
public void setTest2(String test2) {
this.test2 = test2;
}
public int getScore2() {
return score2;
}
public void setScore2(int score2) {
this.score2 = score2;
}
public int getTotalscore() {
return totalscore;
}
public void setTotalscore(int totalscore) {
this.totalscore = totalscore;
}
}
class Answer {
private String num;
private String answer1;
private String answer2;
private int untimatescore;
public int getUntimatescore() {
return untimatescore;
}
public void setUntimatescore(int untimatescore) {
this.untimatescore = untimatescore;
}
public Answer() {
}
public Answer(String num, String answer1, String answer2) {
this.num = num;
this.answer1 = answer1;
this.answer2 = answer2;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public String getAnswer1() {
return answer1;
}
public void setAnswer1(String answer1) {
this.answer1 = answer1;
}
public String getAnswer2() {
return answer2;
}
public void setAnswer2(String answer2) {
this.answer2 = answer2;
}
}

第二次題目集最後一題與第一次題目集最後一題總體相差並不大，大致框架是一樣的，但是相對於第一題來說多了每一題具體的分值，同時還可能出現兩張試卷，不同試卷有不同的題目，還得判斷試卷中題目的分值是否達到一百，並由此出現不同的應對，在第一次的基礎上新增相應程式碼給題目賦分，同時加上一些函式，計算答題卡得分情況並輸出即可。
第三次題目集最後一題：
設計實現答題程式，模擬一個小型的測試，以下粗體字顯示的是在答題判題程式-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=₅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=₅true
4+6=₂₂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。

本題暫不考慮出現多張答卷的資訊的情況。

輸入樣例1:
簡單輸入，不含刪除題目資訊。例如：
解釋

N:1 #Q:1+1= #A:2

T:1 1-5

X:20201103 Tom

N:1 #Q:1+1= #A:2

T:1 1-5

X:20201103 Tom

S:2 20201103 #A:1-5 #A:2-4

end
輸出樣例8:
例如：
alert: full score of test paper1 is not 100 points
The test paper number does not exist
輸入樣例9:
無效的學號引用。例如：
解釋

N:1 #Q:1+1= #A:2

T:1 1-5

X:20201106 Tom

S:1 20201103 #A:1-5 #A:2-4

end
輸出樣例9:
答案照常輸出，判分時提示錯誤。例如：
alert: full score of test paper1 is not 100 points
1+1=₅false
20201103 not found

輸入樣例10:
資訊可打亂順序輸入：序號不是按大小排列，各類資訊交錯輸入。但本題不考慮引用的題目在被引用的資訊之後出現的情況（如試卷引用的所有題目應該在試卷資訊之前輸入），所有引用的資料應該在被引用的資訊之前給出。例如：
解釋

N:3 #Q:中國第一顆原子彈的爆炸時間 #A:1964.10.16

N:1 #Q:1+1= #A:2

X:20201103 Tom-20201104 Jack-20201105 Www

T:1 1-5 3-8

N:2 #Q:2+2= #A:4

S:1 20201103 #A:1-5 #A:2-4

end
輸出樣例10:
答案按試卷中的題目順序輸出。例如：
解釋
alert: full score of test paper1 is not 100 points
1+1=₅false
中國第一顆原子彈的爆炸時間₄false
20201103 Tom: 0 0~0
程式碼如下：
import java.util.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.LinkedList;
import java.util.LinkedHashMap;

public class Main{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
LinkedHashMap<Integer,Question> question = new LinkedHashMap<Integer,Question>();
LinkedHashMap<Integer,TestPaper> testpaper = new LinkedHashMap<Integer,TestPaper>();
LinkedList ans = new LinkedList<>();
LinkedList studentlist = new LinkedList<>();
//輸入
while(true)
{
LinkedHashMap<Integer,String> an = new LinkedHashMap<>();
String newin = input.nextLine();
// System.out.println(newin);
if(newin.equals("end"))
{
break;
}
if(newin.startsWith("#N:"))
{
if(newin.matches("#N:(\s\d+\s)#Q:(.)#A:(.)"))
{
int index1 = newin.indexOf("#N:");
int index2 = newin.indexOf("#Q:");
int index3 = newin.indexOf("#A:");
String num = newin.substring(index1+3,index2).trim();
int number = Integer.parseInt(num);
String content = newin.substring(index2+3,index3).trim();
String standardAnswer = newin.substring(index3+3,newin.length()).trim();
question.put(number,new Question(number,content,standardAnswer,true));
}
else
System.out.println("wrong format:"+newin);
}
else if(newin.startsWith("#T:"))
{
if(newin.matches("#T:\s(\d)\s(\s\d+-\d+\s)"))
{
String regex = "#T:\s(\d+)\s(.)";
Pattern pat = Pattern.compile(regex);
Matcher mat = pat.matcher(newin);
mat.find();
int pid = Integer.parseInt(mat.group(1).trim());
//System.out.printf("%d\n",pid);
TestPaper paper = new TestPaper();
Pattern pat1 = Pattern.compile("(\d+)-(\d+)");
Matcher mat1 = pat1.matcher(newin);
while(mat1.find())
{
int qid=Integer.parseInt(mat1.group(1));
int score =Integer.parseInt(mat1.group(2));
paper.addQuestion(qid,score);
//System.out.printf("%d %d\n",qid,score);
}
testpaper.put(pid,paper);
}
else
System.out.println("wrong format:"+newin);
}
else if(newin.startsWith("#S:"))
{
if(newin.matches("#S:\s(\d+)\s+(\w)\s(#A:\s(\d+-?[^#]))"))
{
String regex = "#S:\s(\d+)\s+(\w)\s(#A:\s(\d+-?[^#]))*";
Pattern pat2 = Pattern.compile(regex);
Matcher mat2 = pat2.matcher(newin);
mat2.find();
int aid = Integer.parseInt(mat2.group(1).trim());
int sid = Integer.parseInt(mat2.group(2).trim());
//System.out.print(aid);

                int count=0;
                if(testpaper.containsKey(aid))
                {
                    Pattern pat3 = Pattern.compile("#A:(\\d+)-?([^#]*)");
                    Matcher mat3 = pat3.matcher(newin);
                    while(mat3.find())
                    {
                        int order =Integer.parseInt (mat3.group(1).trim());
                        String a = mat3.group(2).trim();
                        an.put(order,a);
                        count++;
                    }
                }
                Answer answer = new Answer(an,count,aid,sid);
                ans.add(answer);
            }
            else
                System.out.println("wrong format:"+newin);
        }
        else if(newin.startsWith("#X:"))
        {
            if(newin.matches("#X:\\s*(\\d+)\\s*(.*)(-(\\d+)\\s*(.*))*"))
            {
                Pattern pat4 = Pattern.compile("#X:(\\s*(\\d+)\\s*(.*)(-\\s*(\\d+)\\s*(.*))*)");
                Matcher mat4 = pat4.matcher(newin);
                mat4.find();
                String in = mat4.group(1).trim();
                Pattern pat5 = Pattern.compile("\\s*(\\d+)\\s*(\\w+)\\-*");
                Matcher mat5 = pat5.matcher(newin);
                while(mat5.find())
                {
                    int sid=Integer.parseInt(mat5.group(1).trim());
                    String name = mat5.group(2).trim();
                    //System.out.println(sid+name);
                    Student stu = new Student(sid,name);
                    studentlist.add(stu);
                }
            }
            else
                System.out.println("wrong format:"+newin);
        }
        else if(newin.startsWith("#D:N-"))
        {
            if(newin.matches("#D:N-\\s*\\d+\\s*"))
            {
                Pattern pat6 = Pattern.compile("#D:N-\\s*(\\d+)\\s*");
                Matcher mat6 = pat6.matcher(newin);
                mat6.find();
                int did = Integer.parseInt(mat6.group(1).trim());
                if(question.containsKey(did))
                {
                    question.get(did).setisvalid(false);
                }
            }
            else
                System.out.println("wrong format:"+newin);
        }
        else 
            System.out.println("wrong format:"+newin);
    }


    //輸出
    for(int key:testpaper.keySet())
    {
        if(testpaper.get(key).getfullscore()!=100)
        {
            System.out.println("alert: full score of test paper"+key+" is not 100 points");
        }
    }
    for(Answer a:ans)
    {
        int key=a.getid();
        if(!testpaper.containsKey(a.getid()))
        {
            System.out.println("The test paper number does not exist");
            continue;
        }
        else
        {
            int flag = 0;
            Student student = new Student();
            for(Student stu:studentlist)
            {
                if(a.getsid()==stu.getsid())
                {
                    student=stu;
                    flag=1;
                    break;
                }
            }
            int m=1;
            for(int key1:testpaper.get(key).getquestions().keySet())
            {
                if(a.getanswers().containsKey(m))
                {
                    if(question.containsKey(key1))
                    {
                        if(question.get(key1).getStandardAnswer().equals(a.getanswers().get(m)))
                        {
                            a.setresults(true);
                        }
                        else
                        {
                            a.setresults(false);
                        }
                    }
                }
                else
                {
                    a.setresults(false);
                }
                m++;
            }
            m=0;
            int o=1;
            int all=0;
            if(a.getcount()==0)
            {
                //System.out.println(testpaper.get(key).getnumber());
                for(int z=0;z<testpaper.get(key).getnumber();z++)
                    System.out.println("answer is null");
                if(flag==1)
                {
                    System.out.print(student.getsid()+" "+student.getname()+":");
                    for(int i=0;i<testpaper.get(key).getnumber();i++)
                    {
                        System.out.print(" "+0);
                    }
                    System.out.println("~"+0);
                }
                else
                {
                    System.out.println(a.getsid()+" not found");
                }
            }
            else
            {
                for(int i:testpaper.get(key).getquestions().keySet())
                {
                        if(a.getanswers().containsKey(o))
                        {
                            if(!question.containsKey(i))
                            {
                                System.out.println("non-existent question~0");
                                o++;
                                continue;
                            }
                            if(question.get(i).getisvalid())
                            {
                                System.out.println(question.get(i).getContent()+"~"+a.getanswers().get(o)+"~"+question.get(i).getStandardAnswer().equals(a.getanswers().get(o)));
                                // all+=testpaper.get(key).getquestions().get(i);
                            }
                            else
                            {
                                System.out.println("the question "+i+" invalid~0");
                            }
                        }
                        else
                        {
                            System.out.println("answer is null");
                        }
                o++;
            }
            if(flag==1)
            {
                System.out.print(student.getsid()+" "+student.getname()+":");
                    if(testpaper.get(key).getnumber()==0)
                    {
                        System.out.print(" 0");
                        break;
                    }
                    m=0;
                    o=1;
                    for(int i:testpaper.get(key).getquestions().keySet())
                    {
                        if(a.getanswers().containsKey(o))
                        {
                            if(!question.containsKey(i))
                            {
                                System.out.print(" 0");
                            }
                            else
                            {
                                if(question.get(i).getisvalid())
                                {
                                    if(question.get(i).getStandardAnswer().equals(a.getanswers().get(o)))
                                    {
                                        System.out.print(" "+testpaper.get(key).getquestions().get(i));
                                        all+=testpaper.get(key).getquestions().get(i);
                                    }
                                    else
                                    {
                                        System.out.print(" 0");
                                    }
                                }
                                else
                                {
                                    System.out.print(" 0");
                                }
                            }
                        }
                        else
                        {
                            System.out.print(" 0");
                        }
                        o++;
                    }
                    System.out.println("~"+all);
            }
            else
                System.out.println(a.getsid()+" not found");
            }
        }
    }
}

}
class Question {
public int qid;
private String content;
private String standardAnswer;
private boolean isvalid;
public Question(){

}
public Question(int qid,String content, String standardAnswer,boolean isvalid) {  
    this.qid=qid;
    this.content = content;  
    this.standardAnswer = standardAnswer;  
    this.isvalid = isvalid;
}
public int getqid(){
    return qid;
}
public void setisvalid(boolean isvalid)
{
    this.isvalid=isvalid;
}
public String getContent() {  
    return content;  
}  

public String getStandardAnswer() {  
    return standardAnswer;  
}

public boolean getisvalid()
{
return isvalid;
}
public boolean isCorrectAnswer(String answer) {
return standardAnswer.equals(answer);
}
}

class TestPaper {
private int number=0;
private LinkedHashMap<Integer, Integer> questions = new LinkedHashMap<Integer, Integer>();
private int fullscore=0;
TestPaper()
{

}
public int getnumber()
{
    return number;
}
public int getfullscore()
{
    return fullscore;
}
public Map<Integer, Integer> getquestions(){
    return Collections.unmodifiableMap(questions);
}
public void addQuestion(int qid, int score) {
        questions.put(qid, score);
        fullscore += score;
        number++;
}

}

class Answer {
private int aid;
private int count;
private int sid;
private LinkedHashMap<Integer,String> answers = new LinkedHashMap<>();
private Listresults = new ArrayList();
public Answer(LinkedHashMap<Integer,String>answers,int count,int aid,int sid)
{
this.answers=answers;
this.count=count;
this.aid=aid;
this.sid=sid;
}
public int getid()
{
return aid;
}
public int getcount()
{
return count;
}
public int getsid()
{
return sid;
}
public LinkedHashMap<Integer,String> getanswers(){
return answers;
}
public void setresults(boolean result){
this.results.add(result);
}
public List getresults(){
return results;
}
}

class Student{
private int sid;
private String name;
public int getsid(){
return sid;
}
public String getname(){
return name;
}
public void setsid(int sid){
this.sid=sid;
}
public Student(){}
public Student(int sid,String name){
this.sid=sid;
this.name=name;
}
}

第三次題目集最後一題和前兩次的也是大致相同的結構框架也同樣是多了一些需要補充的內容和功能，在原有程式碼的基礎上進行修改就可以實現。
3.採坑心得:
題目所給的測試樣例只是最終得到結果的一部分，還有一些測試點還需要自己慢慢去摸索，有時候即使測試點透過，也沒有分得，這些都是一些細節方面得問題，需要在寫的時候就非常謹慎，儘量不去犯，不然修改的時候會很難察覺這些細節方面得問題，有一個題目就是一個資料輸入錯誤，導致多花了兩三個小時的時間去查詢修改這個錯誤，非常不應該
4.改進建議:
在寫程式碼時要更加謹慎，同時不能想著一次性就把整體程式碼寫好，要分點進行，出錯了就及時修改，要不然整體寫完卻還是有一些細節方面得錯誤時就難以找到這個錯誤並進行修改。
5.總結：
1.題目的難度和時間相對於上個學期有較大改變，需要儘快適應過來
2.類的構建各類使用還不夠成熟
3.正規表示式的運用並不熟練
4.前期應該化一部分時間完成整體題目的設計，明白基本思路方便後續擴充與最佳化，而不是看到題目直接敲程式碼，這樣後續修修補補會更改困難，而且可能因為前期設計的失誤導致部分功能無法實現進而導致整個程式碼重寫

南昌航空大學23201421-PTA4~6次大作業
2024-06-09
南昌航空大學-22207107-胡優樂-Java第二次Blog大作業
2024-11-23
Java
南昌航空大學pta總結
2024-06-09
南昌航空大學前三次pta作業總結
2024-04-21
南昌航空大學 22207209-侯智慧-第二次blog作業
2024-11-23
南昌航空大學 22207209-侯智慧-第一次blog作業
2024-10-26
南昌空大學第一次PTA小結blog
2024-04-21
南昌航空大學軟院第二次部落格
2024-06-09
南昌航空大學軟體學院23201823第二次blog
2024-06-08
南昌航空大學軟體學院23201823第三次blog
2024-06-29
南昌航空大學-22207316-塗高傑-JAVA第一次blog作業
2024-10-26
Java
南昌航空大學-軟體學院23201813-第一次pta-blog作業
2024-04-21
南昌航空大學軟體學院-23201930-劉靖輝-第一次blog作業
2024-04-21
南昌航空大學-軟體學院-22207107-胡優樂-JAVA第一次Blog作業
2024-10-26
Java
南昌航空大學-軟體學院-22207112-盧翔-JAVAPTA（4-6）部落格
2024-11-23
JavaAPT
南昌航空大學大一下學期java-題目集1~3總結性Blog——蘇禮順23201608
2024-04-20
Java
南昌航空大學大一下學期java題目集4-6總結性Blog-蘇禮順23201608
2024-06-02
Java
大作業
2024-05-26
java大作業
2018-03-19
Java
MySQL大作業
2020-12-03
MySql
南昌哪開票-南昌開票
2020-11-25
Python期末大作業
2020-12-21
Python
南昌工程學院標誌製作
2024-03-26
pta兩次大作業
2024-11-19
軟體工程大作業
2024-06-05
軟體工程
pta大作業總結
2024-06-02
002.04 Tkinter 星空大戰
2019-09-05
OOP大作業二輪總結
2024-06-09
OOP
大作業7-8總結
2024-06-30
第四次大作業到第六次大作業總結
2024-11-23
第二次blog大作業
2024-06-09
綠盟科技走進南昌大學，分享《網路安全產業新進展》主題報告
2021-07-23
產業
關於南昌哪裡可以開餐飲發票-南昌百度派
2020-11-23
前三次大作業總結
2024-04-21
C++大作業二次開發
2024-03-06
C++
oop三次大作業總結
2024-04-21
OOP
pta答題大作業1~3總結
2024-10-26
Java大作業5-6次總結
2024-11-23
Java