NCHU-OOP课程与PTA一到三周作业源代码
PTA-oop-1
答题判断程序-1：
import java.util.*;
public class Main {
public static void main(String[] args) {
Judge judge = new Judge();
Scanner in = new Scanner(System.in);
String input = in.nextLine();
int num = Integer.parseInt(input);
judge.getAnswerPaper().setAnswersNum(num);
judge.getPaper().setProblemsNum(num);
for(int i = 0;i < num;i ++) {
input = in.nextLine();
SplitInputQuestion inputQuestion = new SplitInputQuestion(input);
judge.getPaper().inputProblem(inputQuestion.split());
}
input = in.nextLine();
SplitInputAnswer splitInputAnswer = new SplitInputAnswer(input);
judge.getAnswerPaper().setAnswers(splitInputAnswer.split());
input = in.nextLine();
judge.judgeAnswers();
}
}
class Problem {
private int num = 0;
private String question = "";
private String answer = "";
public Problem() {
}
public Problem(int num, String question, String answer) {
this.num = num;
this.question = question;
this.answer = answer;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String newAnswer) {
answer = newAnswer;
}
public String getQuestion() {
return question;
}
public void setQuestion(String newQuestion) {
question = newQuestion;
}
public int getNum() {
return num;
}
public void setNum(int newNum) {
num = newNum;
}
public boolean judgeAnswer(String answer) {
if(this.answer.equals(answer))
return true;
else
return false;
}
}
class Paper {
private int problemsNum = 0;
private int problemsNumNow = 0;
private Problem[] problems = new Problem[problemsNum];
public Paper() {
}
public void inputProblem(Problem problem) {
if(problemsNumNow < problemsNum) {
problems[problem.getNum() - 1] = problem;
}
problemsNumNow ++;
}
public int getProblemsNum() {
return problemsNum;
}
public void setProblemsNum(int newProblemsNum) {
problemsNum = newProblemsNum;
problems = new Problem[problemsNum];
}
public Problem[] getProblems() {
return problems;
}
public void setProblems(Problem[] newProblems) {
problems = newProblems;
}
}
class AnswerPaper {
private int answersNum = 0;
private String[] answers = new String[answersNum];
public AnswerPaper() {
}
// public void inputAnswer(String answer) {
// //这个本来是想着一个一个加进去的时候用的
// }
// //都没必要列这个加入函数，直接用下面的set就行
// public void inputAnswer(String[] answers) {
// for(int i = 0;i < answers.length;i ++) {
// this.answers[i] = answers[i];
// }
// }
public int getAnswersNum() {
return answersNum;
}
public void setAnswersNum(int newAnswersNum) {
answersNum = newAnswersNum;
answers = new String[answersNum];
}
public String[] getAnswers() {
return answers;
}
public void setAnswers(String[] newAnswers) {
for(int i = 0;i < answersNum;i ++) {
this.answers[i] = newAnswers[i];
}
}
}
class SplitInputQuestion {
private String input = "";
private String[] inputTmp = new String[0];
public SplitInputQuestion(String input) {
this.input = input;
}
public Problem split() {
int num = 0;
String question = "",answer = "";
inputTmp = input.split("#");
for(int i = 0;i < inputTmp.length;i ++) {
if(inputTmp[i].indexOf("N:") >= 0) {//inputTmp[i].matches("N:")
inputTmp[i] = inputTmp[i].replaceAll("N:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
num = Integer.parseInt(inputTmp[i]);
}
else if(inputTmp[i].indexOf("Q:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("Q:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
question = inputTmp[i];
}
else if(inputTmp[i].indexOf("A:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("A:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
answer = inputTmp[i];
}
}
Problem problem = new Problem(num, question, answer); //此处不初始化会报错！！！
return problem;
}
}
class SplitInputAnswer {
private String input;
private String[] inputTmp = new String[0];
public SplitInputAnswer(String input) {
this.input = input;
}
public String[] split() {
inputTmp = input.split("#");
for(int i = 0;i < inputTmp.length;i ++) {
inputTmp[i] = inputTmp[i].replaceAll("A:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
}
inputTmp = Arrays.copyOfRange(inputTmp, 1, inputTmp.length + 1);
return inputTmp;
}
}
class Judge {
private Paper paper = new Paper();
private AnswerPaper answerPaper = new AnswerPaper();
public Judge() {
}
public Paper getPaper() {
return paper;
}
public void setPaper(Paper newPaper) {
paper = newPaper;
}
public AnswerPaper getAnswerPaper() {
return answerPaper;
}
public void setAnswerPaper(AnswerPaper newAnswerPaper) {
answerPaper = newAnswerPaper;
}
public void outputProblemAndAnswer() {
for(int i = 0;i < paper.getProblemsNum();i ++) {
System.out.println(paper.getProblems()[i].getQuestion() + "~" + answerPaper.getAnswers()[i]);
}
}
public void outputAnswer() {
for(int i = 0;i < paper.getProblemsNum();i ++) {
if(paper.getProblems()[i].judgeAnswer(answerPaper.getAnswers()[i]))
System.out.print("true");
else
System.out.print("false");
if(i != paper.getProblemsNum() - 1)
System.out.print(" ");
}
}
public void judgeAnswers() {
this.outputProblemAndAnswer();
this.outputAnswer();
}
}
PTA-oop-2
答题判断程序-2：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int isEnd = 0;
String input = "";
Controller controller = new Controller();
//循环输入，遇end结束
while(true) {
input = in.nextLine();
controller.getInput().setInput(input);
switch(controller.getInput().judgeInput()) {
case 1:
controller.inputProblemsTmp();
break;
case 2:
controller.inputPaper();
break;
case 3:
controller.inputAnswerPaper();
break;
default:
isEnd = 1;
break;
}
//判断是否需要退出输入
if(isEnd == 1)
break;
}
//检查试卷分数是否满100
controller.checkPaper();
//检查对错并输出（输出题目，答案和总分）（集成在judge）
controller.judge();
}
}
class Problem implements Comparable<Problem>{
private int num = 0;
private String question = "";
private String answer = "";
private int score = 0;
public Problem() {
}
public Problem(int num, String question, String answer) {
this.num = num;
this.question = question;
this.answer = answer;
}
public int getNum() {
return num;
}
public void setNum(int newNum) {
num = newNum;
}
public String getQuestion() {
return question;
}
public void setQuestion(String newQuestion) {
question = newQuestion;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String newAnswer) {
answer = newAnswer;
}
public int getScore() {
return score;
}
public void setScore(int newScore) {
score = newScore;
}
public boolean judgeAnswer(String answer) {
if(this.answer.compareTo(answer) == 0)
return true;
else
return false;
}
public int compareTo(Problem problem) {
//正序排列
return this.num - problem.num;
}
}
//之后可能也要对试卷按照编号进行排序，所以也重写下
class Paper implements Comparable<Paper>{
private int num = 0;
private int scoreAll = 0;
private int problemNum = 0;
private ArrayList<Problem> problems = new ArrayList<Problem>();
public Paper() {
}
public Paper(int num) {
this.num = num;
}
public int getNum() {
return num;
}
public void setNum(int newNum) {
num = newNum;
}
public int getProblemsNum() {
return problemNum;
}
public int getScoreAll() {
return scoreAll;
}
public void setScoreAll(int newScoreAll) {
scoreAll = newScoreAll;
}
public void setProblemsNum(int newProblemsNum) {
problemNum = newProblemsNum;
}
public ArrayList<Problem> getProblems() {
return problems;
}
public void setProblems(ArrayList<Problem> newProblems) {
problems = newProblems;
}
public void inputProblem(Problem problem) {
Problem problemTmp = new Problem();
problemTmp.setNum(problem.getNum());
problemTmp.setAnswer(problem.getAnswer());
problemTmp.setQuestion(problem.getQuestion());
problemTmp.setScore(problem.getScore());
problems.add(problemTmp);
//放入时自动更新个数！
problemNum ++;
}
public void sortProblem() {
Collections.sort(problems);
}
public int compareTo(Paper paper) {
return this.num - paper.num;
}
}
class Papers {
private int paperNum = 0;
private ArrayList<Paper> papers = new ArrayList<Paper>();
public Papers() {
}
public int getPaperNum() {
return paperNum;
}
public void setPaperNum(int newPaperNum) {
paperNum = newPaperNum;
}
public ArrayList<Paper> getPapers() {
return papers;
}
public void setPapers(ArrayList<Paper> newPapers) {
papers = newPapers;
}
public int getPapersNum() {
return paperNum;
}
public void setPapersNum(int newPapersNum) {
paperNum = newPapersNum;
}
public void inputPaper(Paper paper) {
papers.add(paper);
//放入时自动更新个数！
paperNum ++;
}
public void sortPapers() {
Collections.sort(papers);
}
}
class Answer {
private int paperNum = 0;
private int problemNum = 0;
private String answer = "";
public Answer(int paperNum, int problemNum, String answer) {
this.paperNum = paperNum;
this.problemNum = problemNum;
this.answer = answer;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String newAnswer) {
this.answer = newAnswer;
}
}
class AnswerPaper {
private int num = 0;//答题对应的试卷编号
private int answerNum = 0;
private ArrayList<Answer> answers = new ArrayList<Answer>();
public AnswerPaper() {
}
public int getNum() {
return num;
}
public void setAnswerNum(int answerNum) {
this.answerNum = answerNum;
}
public int getAnswerNum() {
return answerNum;
}
public void setNum(int num) {
this.num = num;
}
public ArrayList<Answer> getAnswers() {
return answers;
}
public void setAnswers(ArrayList<Answer> newAnswers) {
answers = newAnswers;
}
public void inputAnswer(Answer answer) {
answers.add(answer);
//放入时自动更新个数！
answerNum ++;
}
}
class AnswerPapers {
private int answerspaperNum;
private ArrayList<AnswerPaper> answerPapers = new ArrayList<AnswerPaper>();
public AnswerPapers() {
}
public ArrayList<AnswerPaper> getAnswerPapers() {
return answerPapers;
}
public void setAnswerPapers(ArrayList<AnswerPaper> newAnswerPapers) {
answerPapers = newAnswerPapers;
}
public int getAnswerspaperNum() {
return answerspaperNum;
}
public void setAnswerspaperNum(int newAnswerspaperNum) {
answerspaperNum = newAnswerspaperNum;
}
public void inputAnswer(AnswerPaper answerPaper) {
answerPapers.add(answerPaper);
//放入时自动更新个数！
answerspaperNum ++;
}
}
class Input {
private String input;
public Input() {
}
public Input(String input) {
this.input = input;
}
public int judgeInput() {
//通过判断输入中有什么来判断输入的内容，采取不同操作
if(input.indexOf("#N:") >= 0)
return 1;
else if(input.indexOf("#T:") >= 0)
return 2;
else if(input.indexOf("#S:") >= 0)
return 3;
else if(input.indexOf("end") >= 0)
return 4;
else
return 0;
}
//没法直接返回一个paper，因为这个与paperTmp没有关系
public int[] getPaper() {
//将输入的试卷信息放入数组中，第一位是试卷编号，第二位开始，一个题目编号，一个题目分值
//去掉T等字符
input = input.replaceAll("#T:", "");
//去掉开头结尾空格，防止数组分割多了
input = input.replaceAll("^\\s+", "");
input = input.replaceAll("\\s+$", "");
//-替换为空格
input = input.replaceAll("-", " ");
String[] inputTmp = input.split("\\s+");
int[] inputTmpNum = new int[inputTmp.length];
for(int i = 0;i < inputTmp.length;i ++) {
inputTmpNum[i] = Integer.parseInt(inputTmp[i]);
}
return inputTmpNum;
}
public Problem getProblem() {
String[] inputTmp;
int num = 0;
String question = "",answer = "";
//去掉开头#，防止数组分割多了
input = input.replaceAll("^#", "");
inputTmp = input.split("#");
for(int i = 0;i < inputTmp.length;i ++) {
if(inputTmp[i].indexOf("N:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("N:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
//去掉所有空格后转换
num = Integer.parseInt(inputTmp[i]);
}
else if(inputTmp[i].indexOf("Q:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("Q:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
question = inputTmp[i];
}
else if(inputTmp[i].indexOf("A:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("A:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
answer = inputTmp[i];
}
}
Problem problemTmp = new Problem(num, question, answer);
return problemTmp;
}
public String[] getAnswer() {
//去掉S,A等字符
input = input.replaceAll("#S:", "");
input = input.replaceAll("#A:", "");
//去掉开头结尾空格，防止数组分割多了
input = input.replaceAll("^\\s+", "");
input = input.replaceAll("\\s+$", "");
String[] inputTmp = input.split("\\s+");
return inputTmp;
}
public String getInput() {
return input;
}
public void setInput(String input) {
this.input = input;
}
}
class Controller {
private Paper problemsTmp = new Paper();
private Papers papers = new Papers();
private AnswerPapers answerPapers = new AnswerPapers();
private Input input = new Input();
public Papers getPapers() {
return papers;
}
//输入题目
public void inputProblemsTmp() {
Problem problemTmp = input.getProblem();
//每次添加后problemNum增加（在input时增加，集成在Paper中）
problemsTmp.inputProblem(problemTmp);
//不要排序！！！
//每次输入后排序，保证从小到大
//problemsTmp.sortProblem();
}
//创建试卷
public void inputPaper() {
Paper paperTmp = new Paper();
//根据input返回的数组编排试卷并放入试卷集
int[] numTmp = input.getPaper();
//第一位是试卷编号
paperTmp.setNum(numTmp[0]);
for(int i = 1;i < numTmp.length;i += 2) {
int hasFound = -1;
//先找到这个题
for(int k = 0;k < problemsTmp.getProblemsNum();k ++ ) {
if(problemsTmp.getProblems().get(k).getNum() == numTmp[i]) {
hasFound = k;//存这个题号在第几个
break;
}
}
//没找到报错，找到放入并给分数，更新试卷总分
if(hasFound >= 0) {
//此处get的应该是numTmp中的数减1，因为list从0开始而题目编号从1开始！
paperTmp.inputProblem(problemsTmp.getProblems().get(hasFound));
//为什么在第二次创建试卷时改变score会改变第一个试卷中题目的score？
//原因是因为add进入的实质是把这个对象的管理者（指针）放在了容器中，而在不同试卷中调用同一道题的过程
//实际上都是对那同一个管理者进行的操作，改的都是那个题的score！！！
//唯一解决办法就是在把problem add 进paper时（改inputProblem方法）再创一个problemTmp ，然后把要加入的题的值一一复制给Tmp，把Tmp加入paper中
//这样才能保证在不同试卷中调用同一个题的时候不会改同一个内存区域的problem
paperTmp.getProblems().get(paperTmp.getProblemsNum() - 1).setScore(numTmp[i + 1]);
paperTmp.setScoreAll(paperTmp.getScoreAll() + numTmp[i + 1]);
}
else {
System.out.println("The problem number does not exist");
}
}
//不需要排序，白写了！！！
// //按序号对试卷中题目排序
// paperTmp.sortProblem();
papers.inputPaper(paperTmp);
}
//创建答卷
public void inputAnswerPaper() {
AnswerPaper answerPaperTmp = new AnswerPaper();
String[] answersTmp = input.getAnswer();
//第一位是试卷编号
answerPaperTmp.setNum(Integer.parseInt(answersTmp[0]));
for(int i = 1;i < answersTmp.length;i ++) {
//题号从1开始,放入答案，更新个数（在input时就更新了）
Answer answerTmp = new Answer(Integer.parseInt(answersTmp[0]), i, answersTmp[i]);
answerPaperTmp.inputAnswer(answerTmp);
}
answerPapers.inputAnswer(answerPaperTmp);
}
public void checkPaper() {
//其实感觉在这之前也要对试卷们按照试卷编号排序
//papers.sortPapers();
for(int i = 0;i < papers.getPaperNum();i ++) {
if(papers.getPapers().get(i).getScoreAll() != 100) {
System.out.println("alert: full score of test paper" + papers.getPapers().get(i).getNum() + " is not 100 points");
}
}
}
//对输入的答卷依次判断并输出
public void judge() {
for(int i = 0;i < answerPapers.getAnswerspaperNum();i ++) {
//先判断是否有这张试卷
int hasFound = -1;
for(int k = 0;k < papers.getPaperNum();k ++) {
if(papers.getPapers().get(k).getNum() == answerPapers.getAnswerPapers().get(i).getNum()) {
hasFound = k;
break;
}
}
if(hasFound >= 0) {
//找到这张试卷后，从第一个开始输出答案和回答等
for(int k = 0;k < papers.getPapers().get(hasFound).getProblemsNum();k ++) {
System.out.println(outputAnswer(hasFound, k, i, k));
}
//再次遍历得获得分数
int scoreAll = 0;
for(int k = 0;k < papers.getPapers().get(hasFound).getProblemsNum();k ++) {
int scoreTmp = outputScore(hasFound, k, i, k);
scoreAll += scoreTmp;
System.out.print(scoreTmp);
if(k != papers.getPapers().get(hasFound).getProblemsNum() - 1)
System.out.print(" ");
}
System.out.println("~" + scoreAll);
}
else {
System.out.println("The test paper number does not exist");
}
}
}
//输出题目和答案等(返回字符串)
public String outputAnswer(int paperNum,int problemNum,int answerPaperNum,int answerNum) {
if(answerNum >= answerPapers.getAnswerPapers().get(answerPaperNum).getAnswerNum()) {
return "answer is null";
}
else {
if(papers.getPapers().get(paperNum).getProblems().get(problemNum).judgeAnswer(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(answerNum).getAnswer())) {
return "" + papers.getPapers().get(paperNum).getProblems().get(problemNum).getQuestion() + "~" +
answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(answerNum).getAnswer() + "~true";
}
else {
return "" + papers.getPapers().get(paperNum).getProblems().get(problemNum).getQuestion() + "~" +
answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(answerNum).getAnswer() + "~false";
}
}
}
//判断分数，返回分数
public int outputScore(int paperNum,int problemNum,int answerPaperNum,int answerNum) {
if(answerNum >= answerPapers.getAnswerPapers().get(answerPaperNum).getAnswerNum()) {
return 0;
}
else {
if(papers.getPapers().get(paperNum).getProblems().get(problemNum).judgeAnswer(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(answerNum).getAnswer())) {
return papers.getPapers().get(paperNum).getProblems().get(problemNum).getScore();
}
else {
return 0;
}
}
}
//Getter，Setter方法们
public Paper getProblemsTmp() {
return problemsTmp;
}
public void setPapers(Papers newPapers) {
papers = newPapers;
}
public AnswerPapers getAnswers() {
return answerPapers;
}
public void setAnswers(AnswerPapers newAnswerPapers) {
answerPapers = newAnswerPapers;
}
public Input getInput() {
return input;
}
public void setInput(Input input) {
this.input = input;
}
}
PTA-oop-3
答题判断程序-3：
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int isEnd = 0;
String input = "";
Controller controller = new Controller();
//循环输入，遇end结束
while(true) {
input = in.nextLine();
controller.getInput().setInput(input);
switch(controller.getInput().judgeInput()) {
case 1:
controller.inputProblemsTmp();
break;
case 2:
controller.inputPaper();
break;
case 3:
controller.inputAnswerPaper();
break;
case 4:
controller.inputStudents();
break;
case 5:
controller.deleteProblem();
break;
case 6:
isEnd = 1;
break;
default:
controller.showWrongFormat();
break;
}
//判断是否需要退出输入
if(isEnd == 1)
break;
}
//检查试卷分数是否满100
controller.checkPaper();
//检查对错并输出（输出题目，答案和总分）（集成在judge）
controller.judge();
}
}
class Problem implements Comparable<Problem>{
private int num = 0;
private String question = "";
private String answer = "";
private int score = 0;
public Problem() {
}
public Problem(int num, String question, String answer) {
this.num = num;
this.question = question;
this.answer = answer;
}
public int getNum() {
return num;
}
public void setNum(int newNum) {
num = newNum;
}
public String getQuestion() {
return question;
}
public void setQuestion(String newQuestion) {
question = newQuestion;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String newAnswer) {
answer = newAnswer;
}
public int getScore() {
return score;
}
public void setScore(int newScore) {
score = newScore;
}
public boolean judgeAnswer(String answer) {
if(this.answer.compareTo(answer) == 0)
return true;
else
return false;
}
public int compareTo(Problem problem) {
//正序排列
return this.num - problem.num;
}
}
//之后可能也要对试卷按照编号进行排序，所以也重写下
class Paper implements Comparable<Paper>{
private int num = 0;
private int scoreAll = 0;
private int problemNum = 0;
private ArrayList<Problem> problems = new ArrayList<Problem>();
public Paper() {
}
public Paper(int num) {
this.num = num;
}
public int getNum() {
return num;
}
public void setNum(int newNum) {
num = newNum;
}
public int getProblemsNum() {
return problemNum;
}
public int getScoreAll() {
return scoreAll;
}
public void setScoreAll(int newScoreAll) {
scoreAll = newScoreAll;
}
public void setProblemsNum(int newProblemsNum) {
problemNum = newProblemsNum;
}
public ArrayList<Problem> getProblems() {
return problems;
}
public void setProblems(ArrayList<Problem> newProblems) {
problems = newProblems;
}
public void inputProblem(Problem problem) {
Problem problemTmp = new Problem();
problemTmp.setNum(problem.getNum());
problemTmp.setAnswer(problem.getAnswer());
problemTmp.setQuestion(problem.getQuestion());
problemTmp.setScore(problem.getScore());
problems.add(problemTmp);
//放入时自动更新个数！
problemNum ++;
}
public void sortProblem() {
Collections.sort(problems);
}
public int compareTo(Paper paper) {
return this.num - paper.num;
}
}
class Papers {
private int paperNum = 0;
private ArrayList<Paper> papers = new ArrayList<Paper>();
public Papers() {
}
public int getPaperNum() {
return paperNum;
}
public void setPaperNum(int newPaperNum) {
paperNum = newPaperNum;
}
public ArrayList<Paper> getPapers() {
return papers;
}
public void setPapers(ArrayList<Paper> newPapers) {
papers = newPapers;
}
public int getPapersNum() {
return paperNum;
}
public void setPapersNum(int newPapersNum) {
paperNum = newPapersNum;
}
public void inputPaper(Paper paper) {
papers.add(paper);
//放入时自动更新个数！
paperNum ++;
}
public void sortPapers() {
Collections.sort(papers);
}
}
class Answer {
private int paperNum = 0;
private int problemNum = 0;
private String answer = "";
public Answer(int paperNum, int problemNum, String answer) {
this.paperNum = paperNum;
this.problemNum = problemNum;
this.answer = answer;
}
public int getPaperNum() {
return paperNum;
}
public void setPaperNum(int paperNum) {
this.paperNum = paperNum;
}
public int getProblemNum() {
return problemNum;
}
public void setProblemNum(int problemNum) {
this.problemNum = problemNum;
}
public String getAnswer() {
return answer;
}
public void setAnswer(String newAnswer) {
this.answer = newAnswer;
}
}
class AnswerPaper {
private int num = 0;//答题对应的试卷编号
private int answerNum = 0;
private String studentID = "";
private ArrayList<Answer> answers = new ArrayList<Answer>();
public AnswerPaper() {
}
public int getNum() {
return num;
}
public void setAnswerNum(int answerNum) {
this.answerNum = answerNum;
}
public int getAnswerNum() {
return answerNum;
}
public void setNum(int num) {
this.num = num;
}
public String getStudentID() {
return studentID;
}
public void setStudentID(String studentID) {
this.studentID = studentID;
}
public ArrayList<Answer> getAnswers() {
return answers;
}
public void setAnswers(ArrayList<Answer> newAnswers) {
answers = newAnswers;
}
public void inputAnswer(Answer answer) {
answers.add(answer);
//放入时自动更新个数！
answerNum ++;
}
}
class AnswerPapers {
private int answerspaperNum = 0;
private ArrayList<AnswerPaper> answerPapers = new ArrayList<AnswerPaper>();
public AnswerPapers() {
}
public ArrayList<AnswerPaper> getAnswerPapers() {
return answerPapers;
}
public void setAnswerPapers(ArrayList<AnswerPaper> newAnswerPapers) {
answerPapers = newAnswerPapers;
}
public int getAnswerspaperNum() {
return answerspaperNum;
}
public void setAnswerspaperNum(int newAnswerspaperNum) {
answerspaperNum = newAnswerspaperNum;
}
public void inputAnswer(AnswerPaper answerPaper) {
answerPapers.add(answerPaper);
//放入时自动更新个数！
answerspaperNum ++;
}
}
class Student {
private String name = "";
private String studentID = "";
public Student() {
}
public Student(String name, String studentId) {
this.name = name;
this.studentID = studentId;
}
public String getStudentID() {
return studentID;
}
public void setStudentID(String newStudentID) {
studentID = newStudentID;
}
public String getName() {
return name;
}
public void setName(String newName) {
name = newName;
}
}
class Class {
private int num = 0;
private int studentNum = 0;//当前学生总数
private ArrayList<Student> students = new ArrayList<Student>();
public Class() {
}
public int getNum() {
return num;
}
public void setNum(int newNum) {
num = newNum;
}
public int getStudentNum() {
return studentNum;
}
public void setStudentNum(int studentNum) {
this.studentNum = studentNum;
}
public ArrayList<Student> getStudents() {
return students;
}
public void setStudents(ArrayList<Student> newStudents) {
students = newStudents;
}
public void inputStudent(Student student) {
students.add(student);
studentNum++;
}
}
class Input {
private String input;
public Input() {
}
public Input(String input) {
this.input = input;
}
public int judgeInput() {
//需要对输入完善判断(要保证了输入必须严格按照格式，序号只能为数字等)
// //通过判断输入中有什么来判断输入的内容，采取不同操作
// if(input.matches("(\\s*#N:\\s*[0-9]+\\s+?#Q:[^#]+\\s+?#A:[^#]*){1}\\s*"))
// return 1;
// //试卷好像不能没有题目
// else if(input.matches("\\s*#T:\\s*[0-9]+\\s*") || input.matches("(\\s*#T:\\s*[0-9]+\\s*){1}(\\s+[0-9]+-[0-9]+){1,}\\s*"))
// return 2;
// //修改：答案可以为空！答案还可以是有空格的句子！！！
//// else if(input.matches("(\\s*#S:\\s*[0-9]+\\s+[^#\\s]+){1}\\s*") || input.matches("(\\s*#S:\\s*[0-9]+\\s+?[^# ]+){1}(\\s+#A:\\s*[0-9]+-[^\\s]*){1,}\\s*"))
// //暂时认为学号均为数字
//// else if(input.matches("(\\s*#S:\\s*[0-9]+\\s+[0-9]+){1}\\s*") || input.matches("(\\s*#S:\\s*[0-9]+\\s+?[0-9]+){1}(\\s+#A:\\s*[0-9]+-.*?){1,}\\s*"))
// else if(input.matches("(\\s*#S:\\s*[0-9]+\\s+[0-9]+){1}\\s*") || input.matches("(\\s*#S:\\s*[0-9]+\\s+?[0-9]+\\s+){1}(\\s*#A:\\s*[0-9]+-[^#]*){1,}\\s*"))
// return 3;
//// else if(input.matches("(\\s*#X:\\s*){1}") || input.matches("(\\s*#X:\\s*){1}([^ ]+\\s+[^- ]+-){0,}([^ ]+\\s+[^- ]+){1}\\s*"))
// else if(input.matches("(\\s*#X:\\s*){1}") || input.matches("(\\s*#X:\\s*){1}([0-9]+\\s+[^- ]+-){0,}([0-9]+\\s+[^- ]+){1}\\s*"))
// return 4;
// else if(input.matches("\\s*#D:\\s*") || input.matches("\\s*#D:\\s*N-[0-9]+\\s*"))
// return 5;
// else if(input.indexOf("end") >= 0)
// return 6;
// //若非以上情况，说明输入更不合法！返回0
// else
// return 0;
//通过判断输入中有什么来判断输入的内容，采取不同操作
if(input.matches("#N:\\d+\\s+#Q:[^#]*#A:.*"))
return 1;
else if(input.matches("(#T:\\d+){1}(\\s+[0-9]+-[0-9]+){0,}\\s*"))
return 2;
else if(input.matches("(#S:\\d+\\s+\\d+\\s*){1}(\\s*#A:\\s*\\d+-[^#]*){0,}\\s*"))
return 3;
else if(input.matches("(\\s*#X:\\s*){1}(\\d+\\s+[^- ]+-){0,}(\\d+\\s+.+){1}\\s*"))
return 4;
else if(input.matches("\\s*#D:\\s*N-\\d+\\s*"))
return 5;
else if(input.indexOf("end") >= 0)
return 6;
//若非以上情况，说明输入更不合法！返回0
else
return 0;
}
//获得创建的试卷中的信息（放入哪些题还有分数）
//没法直接返回一个paper，因为这个与paperTmp没有关系
public int[] getPaper() {
//将输入的试卷信息放入数组中，第一位是试卷编号，第二位开始，一个题目编号，一个题目分值
//去掉T等字符
input = input.replaceAll("#T:", "");
//去掉开头结尾空格，防止数组分割多了
input = input.replaceAll("^\\s+", "");
input = input.replaceAll("\\s+$", "");
//-替换为空格
input = input.replaceAll("-", " ");
String[] inputTmp = input.split("\\s+");
int[] inputTmpNum = new int[inputTmp.length];
for(int i = 0;i < inputTmp.length;i ++) {
inputTmpNum[i] = Integer.parseInt(inputTmp[i]);
}
return inputTmpNum;
}
//获得题目
public Problem getProblem() {
String[] inputTmp;
int num = 0;
String question = "",answer = "";
//去掉开头#，防止数组分割多了
input = input.replaceAll("^#", "");
inputTmp = input.split("#");
for(int i = 0;i < inputTmp.length;i ++) {
if(inputTmp[i].indexOf("N:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("N:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
//去掉所有空格后转换
num = Integer.parseInt(inputTmp[i]);
}
else if(inputTmp[i].indexOf("Q:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("Q:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
question = inputTmp[i];
}
else if(inputTmp[i].indexOf("A:") >= 0) {
inputTmp[i] = inputTmp[i].replaceAll("A:","");
inputTmp[i] = inputTmp[i].replaceAll("^\\s+","");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$","");
answer = inputTmp[i];
}
}
Problem problemTmp = new Problem(num, question, answer);
return problemTmp;
}
//获取单次（单张试卷）的回答
//oop3中试卷答案的输入格式改了，每个回答都有对应的题目
//同时因为答案可以为空，所以需要修改分割的逻辑！
//最重要的是回答可以为一句话！！！
public String[] getAnswer() {
//去掉S字符
input = input.replaceAll("#S:", "");
//去掉开头结尾空格，防止数组分割多了
input = input.replaceAll("^\\s+", "");
input = input.replaceAll("\\s+$", "");
//以-或#A:为界限分割
String[] inputTmp = input.split("-|#A:");
//再遍历一次分割后的字符串数组，去掉不该有的空格
for(int i = 0;i < inputTmp.length;i ++) {
inputTmp[i] = inputTmp[i].replaceAll("^\\s+", "");
inputTmp[i] = inputTmp[i].replaceAll("\\s+$", "");
}
return inputTmp;
}
//获得学生们的信息（学号姓名）
public String[] getStudent() {
//去掉X等字符
input = input.replaceAll("#X:", "");
//把-换成空格方便拆分
input = input.replaceAll("-", " ");
//去掉开头结尾空格，防止数组分割多了
input = input.replaceAll("^\\s+", "");
input = input.replaceAll("\\s+$", "");
String[] inputTmp = input.split("\\s+");
return inputTmp;
}
//获得删除的题号
public int getDelete() {
//去掉D,N等字符
input = input.replaceAll("#D:", "");
input = input.replaceAll("N-", "");
//去掉开头结尾空格，防止在转整数的时候还有空格导致出错
input = input.replaceAll("^\\s+", "");
input = input.replaceAll("\\s+$", "");
int inputTmp = Integer.parseInt(input);
return inputTmp;
}
public String getInput() {
return input;
}
public void setInput(String input) {
this.input = input;
}
}
class Controller {
private Paper problemsTmp = new Paper();
private Papers papers = new Papers();
private AnswerPapers answerPapers = new AnswerPapers();
private Input input = new Input();
private Class class1 = new Class();
public Papers getPapers() {
return papers;
}
//输入题目
public void inputProblemsTmp() {
Problem problemTmp = input.getProblem();
//每次添加后problemNum增加（在input时增加，集成在Paper中）
problemsTmp.inputProblem(problemTmp);
}
//创建试卷
public void inputPaper() {
Paper paperTmp = new Paper();
//根据input返回的数组编排试卷并放入试卷集
int[] numTmp = input.getPaper();
//第一位是试卷编号
paperTmp.setNum(numTmp[0]);
for(int i = 1;i < numTmp.length;i += 2) {
int hasFound = -1;
//先找到这个题
for(int k = 0;k < problemsTmp.getProblemsNum();k ++ ) {
if(problemsTmp.getProblems().get(k).getNum() == numTmp[i]) {
hasFound = k;//存这个题号在第几个
break;
}
}
//找到就放入并给分数，更新试卷总分
if(hasFound >= 0) {
//此处get的应该是numTmp中的数减1，因为list从0开始而题目编号从1开始！
paperTmp.inputProblem(problemsTmp.getProblems().get(hasFound));
paperTmp.getProblems().get(paperTmp.getProblemsNum() - 1).setScore(numTmp[i + 1]);
paperTmp.setScoreAll(paperTmp.getScoreAll() + numTmp[i + 1]);
}
//没找到就和被删除类似处理,放入一个新的,在问题中表示错误信息
else {
Problem problemTmp = new Problem();
problemTmp.setNum(numTmp[i]);
problemTmp.setQuestion("non-existent");
problemTmp.setScore(0);
paperTmp.inputProblem(problemTmp);
}
}
papers.inputPaper(paperTmp);
}
//创建学生并放入Class
public void inputStudents() {
String[] studentsTmp = input.getStudent();
//遍历studentsTmp，偶数位是学号，奇数是对应学生
for(int i = 0; i < studentsTmp.length; i += 2) {
Student studentTmp = new Student(studentsTmp[i + 1], studentsTmp[i]);
class1.inputStudent(studentTmp);
}
}
//获取删除的题目并删除
public void deleteProblem() {
int deleteNum = input.getDelete();
//遍历查找删除的题目是否存在
int hasFound = -1;
for(int k = 0;k < problemsTmp.getProblemsNum(); k ++) {
if(problemsTmp.getProblems().get(k).getNum() == deleteNum) {
hasFound = k;
break;
}
}
//找到后删除题目集中的这道题，并且在已经创建的试卷中搜索并修改
if(hasFound >= 0) {
problemsTmp.getProblems().remove(hasFound);
//同时要修改problemsTmp中的problemsNum！
problemsTmp.setProblemsNum(problemsTmp.getProblemsNum() - 1);
for(int k = 0;k < papers.getPaperNum();k ++) {
for(int j = 0;j < papers.getPapers().get(k).getProblems().size();j ++) {
if(papers.getPapers().get(k).getProblems().get(j).getNum() == deleteNum) {
papers.getPapers().get(k).getProblems().get(j).setQuestion("invalid");
//在删除后，要对本张试卷的总分进行修改！！！
//这样删除后如果分数不满100才会输出警告！！！
papers.getPapers().get(k).setScoreAll(papers.getPapers().get(k).getScoreAll() - papers.getPapers().get(k).getProblems().get(j).getScore());
papers.getPapers().get(k).getProblems().get(j).setScore(0);
// //同时要对本章试卷中的题目总数(problemsNum)修改！
// papers.getPapers().get(k).setProblemsNum(papers.getPapers().get(k).getProblemsNum() - 1);
}
}
}
}
}
//创建答卷
public void inputAnswerPaper() {
AnswerPaper answerPaperTmp = new AnswerPaper();
String[] answersTmp = input.getAnswer();
//第一位包括试卷编号和学号
String[] numsTmp = answersTmp[0].split("\\s+");
answerPaperTmp.setNum(Integer.parseInt(numsTmp[0]));
answerPaperTmp.setStudentID(numsTmp[1]);
for(int i = 1;i < answersTmp.length;i += 2) {
//题号从1开始,放入答案和题目试卷编号，更新个数（在input时就更新了）
//此时的第二个参数表示的是这个答案回答的题目序号（在paper中的次序！！！而不是实际题目编号）
int paperNumTmp = Integer.parseInt(numsTmp[0]);
int probelmNumTmp = Integer.parseInt(answersTmp[i]);
String answerTmp1 = "";
//若回答的最后一道题的答案为空，无论怎样的正则表达式都没法分出来，导致数组大小比正常小1，所以在此进行判断
if(i + 1 < answersTmp.length) {
answerTmp1 = answersTmp[i + 1];
}
Answer answerTmp = new Answer(paperNumTmp, probelmNumTmp, answerTmp1);
answerPaperTmp.inputAnswer(answerTmp);
}
answerPapers.inputAnswer(answerPaperTmp);
}
public void checkPaper() {
for(int i = 0;i < papers.getPaperNum();i ++) {
if(papers.getPapers().get(i).getScoreAll() != 100) {
System.out.println("alert: full score of test paper" + papers.getPapers().get(i).getNum() + " is not 100 points");
}
}
}
//对于错误输入的返回
public void showWrongFormat() {
System.out.println("wrong format:" + input.getInput());
}
//对输入的答卷依次判断并输出
public void judge() {
for(int i = 0;i < answerPapers.getAnswerspaperNum();i ++) {
//先判断是否有这张试卷
int hasFound = -1;
for(int k = 0;k < papers.getPaperNum();k ++) {
if(papers.getPapers().get(k).getNum() == answerPapers.getAnswerPapers().get(i).getNum()) {
hasFound = k;
break;
}
}
//找到这张试卷后，再寻找对应的学生是否存在
if(hasFound >= 0) {
int hasFound2 = -1;
for(int k = 0;k < class1.getStudentNum();k ++) {
//还是那个问题，此处比较String相等只能用equal！！！
if(class1.getStudents().get(k).getStudentID().equals(answerPapers.getAnswerPapers().get(i).getStudentID())) {
hasFound2 = k;
break;
}
}
//不论有没有找到学生信息，只要卷子存在，就正常输出题目和回答
//这里之前因为删除题目时problemsNum没有修改出错了！
for(int k = 0;k < papers.getPapers().get(hasFound).getProblemsNum();k ++) {
//这里的参数要修改，第二个是试卷上本题的实际题号（在problemsTmp中的）//不对，不用改！应该改方法内部的
System.out.println(outputAnswer(hasFound, k, i, k));
}
//如果找到学生信息，输出得分
if(hasFound2 >= 0) {
System.out.print(class1.getStudents().get(hasFound2).getStudentID() + " " + class1.getStudents().get(hasFound2).getName() + ": ");
//再次遍历得获得分数
int scoreAll = 0;
for(int k = 0;k < papers.getPapers().get(hasFound).getProblemsNum();k ++) {
int scoreTmp = outputScore(hasFound, k, i, k);
scoreAll += scoreTmp;
System.out.print(scoreTmp);
if(k != papers.getPapers().get(hasFound).getProblemsNum() - 1)
System.out.print(" ");
}
System.out.println("~" + scoreAll);
}
//没找到学生信息就报错
else {
System.out.println(answerPapers.getAnswerPapers().get(i).getStudentID() + " not found");
}
}
//没找到这张试卷就报错,不再向下判断
else {
System.out.println("The test paper number does not exist");
}
}
}
//输出题目和答案等(返回字符串)，要对卷子中的每个题在答卷中进行搜索，看看有没有回答这道题
public String outputAnswer(int paperNum,int problemNum,int answerPaperNum,int answerNum) {
//参数中的problemNum是本题在这张试卷中的位置！需要在查找时换成实际的题号（在problemsTmp中的）
//上述说明不对，要用这里的problemNum（本题目在试卷中的位置）和每一个answer中的problemNum（也是在试卷中的次序，但是要减一）来比较！
//这段题目描述不清楚，应该先找题目存不存在？
//不是，还是先找本题有没有被回答！要找
//找本题是否被作答
int hasFound = -1;
for(int i = 0;i < answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().size(); i ++) {
//此处前一个是在试卷中的次序，需要-1！
if(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(i).getProblemNum() - 1 == problemNum/*papers.getPapers().get(paperNum).getProblems().get(problemNum).getNum()*/) {
hasFound = i;
break;
}
}
//如果找到了，先判断这个题目存不存在（被删除或者引用错误），然后再看是否回答正确了
if(hasFound >= 0) {
//题目删除和引用错误不会同时出现，所以要逐个判断
//这里的problemNum还是位次！（在paper中按顺序一个个判断）
if(papers.getPapers().get(paperNum).getProblems().get(problemNum).getQuestion().equals("non-existent")) {
return "non-existent question~0";
}
else if(papers.getPapers().get(paperNum).getProblems().get(problemNum).getQuestion().equals("invalid")) {
return "the question " + (problemNum + 1) /*papers.getPapers().get(paperNum).getProblems().get(problemNum).getNum()*/ + " invalid~0";
}
// //因为在输入回答时（输入并创建答卷时）答案可能为空，这里还要再判断答案是不是空的，若是，按没有回答处理
// else if(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(hasFound).getAnswer().equals("")) {
// return "answer is null";
// }
else {
if(papers.getPapers().get(paperNum).getProblems().get(problemNum).judgeAnswer(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(hasFound).getAnswer())) {
return "" + papers.getPapers().get(paperNum).getProblems().get(problemNum).getQuestion() + "~" +
answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(hasFound).getAnswer() + "~true";
}
else {
return "" + papers.getPapers().get(paperNum).getProblems().get(problemNum).getQuestion() + "~" +
answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(hasFound).getAnswer() + "~false";
}
}
}
//没找到返回答案为空
else {
return "answer is null";
}
}
//判断分数，返回分数
public int outputScore(int paperNum,int problemNum,int answerPaperNum,int answerNum) {
// 和输出答案正误的方法一样，这里的参数problemNum是本题在试卷中的位次，需要找到答卷中对应位次的回答
// 找到后比较，找不到返回0
//找本题是否被作答
int hasFound = -1;
for(int i = 0;i < answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().size(); i ++) {
//此处前一个是在试卷中的次序，需要-1！
if(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(i).getProblemNum() - 1 == problemNum) {
hasFound = i;
break;
}
}
if(hasFound >= 0) {
if(papers.getPapers().get(paperNum).getProblems().get(problemNum).judgeAnswer(answerPapers.getAnswerPapers().get(answerPaperNum).getAnswers().get(hasFound).getAnswer())) {
return papers.getPapers().get(paperNum).getProblems().get(problemNum).getScore();
}
else {
return 0;
}
}
else {
return 0;
}
}
//Getter，Setter方法们
public Paper getProblemsTmp() {
return problemsTmp;
}
public void setPapers(Papers newPapers) {
papers = newPapers;
}
public AnswerPapers getAnswers() {
return answerPapers;
}
public void setAnswers(AnswerPapers newAnswerPapers) {
answerPapers = newAnswerPapers;
}
public Input getInput() {
return input;
}
public void setInput(Input input) {
this.input = input;
}
}
浙公网安备 33010602011771号