Java第一次blog
7-1 答题判题程序-1
前言
这些题目主要用到对象与类的处理：
对象是现实世界或抽象概念中的实体在计算机程序中的表示。
类则是具有相同属性和方法的对象的集合，是创建对象的模板。通过类，我们可以定义一类对象的共同特征和行为。
1.字符串处理：需要对输入的题目信息和答题信息进行字符串分割、提取和处理，以获取题目编号、题目内容、标准答案和答题结果等信息。
2.对象和类：需要设计题目类、试卷类和答卷类，使用面向对象的思想来封装题目信息、试卷信息和答卷信息，以便于管理和操作。
3.集合类：需要使用集合类来保存题目列表、答案列表和判题结果列表，以便于对题目和答案进行管理和操作。
4.输入输出：可以考虑从文件中读取题目信息和答题信息，并将判题结果输出到数组中，以实现数据的持久化和方便查看。
5.算法设计：需要设计判题的算法，即根据标准答案和用户答案来判断答题结果是否正确，可以使用字符串比较或其他方法来实现。
题量大难度高
题目1
分数 50
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，要求输入题目信息和答题信息，根据输入题目信息中的标准答案判断答题的结果。
输入格式:
程序输入信息分三部分：
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
设计建议:
以下是针对以上题目要求的设计建议，其中的属性、方法为最小集，实现代码中可根据情况添加所需的内容：
题目类（用于封装单个题目的信息）：
属性：题目编号、题目内容、标准答案-standardAnswer
方法：数据读写set\get方法、判题方法(答案-answer）：判断答案-answer是否符合标准答案-standardAnswer
试卷类（用于封装整套题目的信息）
属性：题目列表(题目类的对象集合)、题目数量
方法：判题方法(题号-num、答案-answer）：判断答案-answer是否符合对应题号的题目标准答案-standardAnswer
保存题目(题号-num、题目-question）：将题目保存到题目列表中，保存位置与num要能对应
答卷类（用于封装答题信息）
属性：试卷（试卷类的对象）、答案列表（保存每一题的答案）、判题列表（保存每一题的判题结果true/false）
方法：判题方法(题号-num）：判断答案列表中第num题的结果是否符合试卷中对应题号的题目标准答案
输出方法(题号-num）：按照题目的格式要求，输出题号为num的题目的内容和答题结果。
保存一个答案(题号-num,答案-answer)：保存题号为num的题目的答题结果answer。
代码长度限制
16 KB 时间限制 400 ms 内存限制 64 MB 栈限制 8192 KB C (gcc) 1
分析题目1可知：
一共要设计出三个类：
题目类，试卷类，答卷类；
如以下代码：//有些部分和题目要求不同可自行更改
//问题类
public static class Question {
private int questionNumber;
private String questionContent;
private String standardAnswer;
public void setQuestionNumber(int questionNumber) {
this.questionNumber = questionNumber;
}
public int getQuestionNumber() {
return this.questionNumber;
}
public void setQuestionContent(String questionContent) {
this.questionContent = questionContent.trim();
}
public String getQuestionContent() {
return this.questionContent;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public String getStandardAnswer() {
return this.standardAnswer;
}
}
// 试卷类
public static class ExamPaper {
private int numQuestions;
private Question e[];//用于存储题目
public void saveQuestion(int numQuestions, Question e[]) {
this.numQuestions=numQuestions;
this.e=new Question[e.length];
for(int i=0;i<e.length;i++)
{
this.e[i]=e[i];
}
for(int i=0;i<e.length-1;i++)
{
for(int j=0;j<e.length-i-1;j++)
{
if(this.e[j].questionNumber>this.e[j+1].questionNumber)
{
Question a=this.e[j];
this.e[j]=this.e[j+1];
this.e[j+1]=a;
}
}
}
}
public int getnum(){
return numQuestions;
}
}
// 答卷类
public static class AnswerSheet {
private ExamPaper examPaper;
private String questionAnther[];//用于存储学生答案
private int i=0;//记录回答的答案个数
public AnswerSheet(ExamPaper examPaper) {
this.examPaper = examPaper;
}
public void saveAnswer(String answer1, String answer2) {
questionAnther=new String[this.examPaper.getnum()];
questionAnther[i]=answer1;
i++;
questionAnther[i]=answer2;
i++;
}
public void saveAnswer(String answer1) {
if(questionAnther==null)
{
questionAnther=new String[this.examPaper.getnum()];
questionAnther[i]=answer1;
}
else
{
questionAnther[i]=answer1;
}
i++;
}
public void output() {//输出结果
for(int j=0;j<this.examPaper.getnum();j++)
{
System.out.println(examPaper.e[j].questionContent+"~"+questionAnther[j]);
}
for(int k=0;k<questionAnther.length;k++)
{
if(k!=questionAnther.length-1)
System.out.printf("%s ",examPaper.e[k].getStandardAnswer().equalsIgnoreCase(questionAnther[k]));
else
System.out.printf("%s",examPaper.e[k].getStandardAnswer().equalsIgnoreCase(questionAnther[k]));
}
}
}
改进1：
private Question e[];可以用hashmap("key:<Integer> questNumber","value:<Question> q");改省很多代码；
private String questionAnther[];//可以用hashmap("key:<Integer> questNumber","value:<String> questionAnther")，省去AnswerSheet中的i;
读取输入代码1
for (int i=0;i<numQuestions;i++)//已知题目个数及输入格式
{
String line=p.nextLine();直接读取输入代码；
Matcher matcher=Pattern.compile("#N:\\ *(\\d+)\\ *#Q:(.+)\\ *#A:(.+)\\ *").matcher(line);//匹配器及捕获器
if (matcher.find())
{
int questionNumber=Integer.parseInt(matcher.group(1));//捕获组
String questionContent=matcher.group(2);
String questionAnther=matcher.group(3);
Question a1=new Question();
a1.setQuestionNumber(questionNumber);
a1.setQuestionContent(questionContent);
a1.setStandardAnswer(questionAnther);
a[i]=a1;
}
}
q.saveQuestion(numQuestions,a);
AnswerSheet o=new AnswerSheet(q);
String questionAnther1;
String questionAnther2;
if(numQuestions==1)
{
String line=p.nextLine();
Matcher matcher=Pattern.compile("#A:(.+)").matcher(line);
if (matcher.find())
{
questionAnther1=matcher.group(1).trim();
o.saveAnswer(questionAnther1);
}
}
else
{
String line=p.nextLine();
String Line[]=line.split(" ");//分割出想要的答案等(//s)
for(int j=0;j<Line.length;j++)
{
Matcher matcher=Pattern.compile("#A:(.+)").matcher(Line[j]);
if (matcher.find())
{
questionAnther1=matcher.group(1).trim();
o.saveAnswer(questionAnther1);
}
}
}
完整代码1
有问题可自行更改仅供参考。
点击查看代码
import java.util.Scanner;
import java.util.regex.*;
public class Main {
public static void main(String[] args) {
Scanner p=new Scanner(System.in);
int numQuestions=p.nextInt();
p.nextLine();
Question a[]=new Question[numQuestions];
ExamPaper q=new ExamPaper();
for (int i=0;i<numQuestions;i++)
{
String line=p.nextLine();
Matcher matcher=Pattern.compile("#N:\\ *(\\d+)\\ *#Q:(.+)\\ *#A:(.+)\\ *").matcher(line);
if (matcher.find())
{
int questionNumber=Integer.parseInt(matcher.group(1));
String questionContent=matcher.group(2);
String questionAnther=matcher.group(3);
Question a1=new Question();
a1.setQuestionNumber(questionNumber);
a1.setQuestionContent(questionContent);
a1.setStandardAnswer(questionAnther);
a[i]=a1;
}
}
q.saveQuestion(numQuestions,a);
AnswerSheet o=new AnswerSheet(q);
String questionAnther1;
String questionAnther2;
if(numQuestions==1)
{
String line=p.nextLine();
Matcher matcher=Pattern.compile("#A:(.+)").matcher(line);
if (matcher.find())
{
questionAnther1=matcher.group(1).trim();
o.saveAnswer(questionAnther1);
}
}
else
{
String line=p.nextLine();
String Line[]=line.split(" ");
for(int j=0;j<Line.length;j++)
{
Matcher matcher=Pattern.compile("#A:(.+)").matcher(Line[j]);
if (matcher.find())
{
questionAnther1=matcher.group(1).trim();
o.saveAnswer(questionAnther1);
}
}
}
o.output();
}
//问题类
public static class Question {
private int questionNumber;
private String questionContent;
private String standardAnswer;
public void setQuestionNumber(int questionNumber) {
this.questionNumber = questionNumber;
}
public int getQuestionNumber() {
return this.questionNumber;
}
public void setQuestionContent(String questionContent) {
this.questionContent = questionContent.trim();
}
public String getQuestionContent() {
return this.questionContent;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public String getStandardAnswer() {
return this.standardAnswer;
}
}
// 试卷类
public static class ExamPaper {
private int numQuestions;
private Question e[];
public void saveQuestion(int numQuestions, Question e[]) {
this.numQuestions=numQuestions;
this.e=new Question[e.length];
for(int i=0;i<e.length;i++)
{
this.e[i]=e[i];
}
for(int i=0;i<e.length-1;i++)
{
for(int j=0;j<e.length-i-1;j++)
{
if(this.e[j].questionNumber>this.e[j+1].questionNumber)
{
Question a=this.e[j];
this.e[j]=this.e[j+1];
this.e[j+1]=a;
}
}
}
}
public int getnum(){
return numQuestions;
}
}
// 答卷类
public static class AnswerSheet {
private ExamPaper examPaper;
private String questionAnther[];
private int i=0;
public AnswerSheet(ExamPaper examPaper) {
this.examPaper = examPaper;
}
public void saveAnswer(String answer1, String answer2) {
questionAnther=new String[this.examPaper.getnum()];
questionAnther[i]=answer1;
i++;
questionAnther[i]=answer2;
i++;
}
public void saveAnswer(String answer1) {
if(questionAnther==null)
{
questionAnther=new String[this.examPaper.getnum()];
questionAnther[i]=answer1;
}
else
{
questionAnther[i]=answer1;
}
i++;
}
public void output() {
for(int j=0;j<this.examPaper.getnum();j++)
{
System.out.println(examPaper.e[j].questionContent+"~"+questionAnther[j]);
}
for(int k=0;k<questionAnther.length;k++)
{
if(k!=questionAnther.length-1)
System.out.printf("%s ",examPaper.e[k].getStandardAnswer().equalsIgnoreCase(questionAnther[k]));
else
System.out.printf("%s",examPaper.e[k].getStandardAnswer().equalsIgnoreCase(questionAnther[k]));
}
}
}
}
题目2
7-4 答题判题程序-2
分数 73
困难
作者 蔡轲
单位 南昌航空大学
设计实现答题程序，模拟一个小型的测试，以下粗体字显示的是在答题判题程序-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=~22~false.
answer is null
3、判分信息
判分信息为一行数据，是一条答题记录所对应试卷的每道小题的计分以及总分，计分输出的先后顺序与题目题号相对应。
格式：题目得分+" "+....+题目得分+"~"+总分
格式约束：
1、没有输入答案的题目计0分
2、判题信息的顺序与输入答题信息中的顺序相同
样例：5 8 0~13
根据输入的答卷的数量以上2、3项答卷信息与判分信息将重复输出。
4、提示错误的试卷号
如果答案信息中试卷的编号找不到，则输出”the test paper number does not exist”，参见样例9。
设计建议：
参考答题判题程序-1，建议增加答题类，类的内容以及类之间的关联自行设计。
输入样例1:
一张试卷一张答卷。试卷满分不等于100。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-5 2-8
#S:1 #A:5 #A:22
end
输出样例1:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
1+1=~5~false
2+2=~22~false
0 0~0
输入样例2:
一张试卷一张答卷。试卷满分不等于100。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#S:1 #A:5 #A:22
end
输出样例2:
在这里给出相应的输出。例如：
1+1=~5~false
2+2=~22~false
0 0~0
输入样例3:
一张试卷、一张答卷。各类信息混合输入。例如：
#N:1 #Q:1+1= #A:2
#N:2 #Q:2+2= #A:4
#T:1 1-70 2-30
#N:3 #Q:3+2= #A:5
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
1+1=~5~false
2+2=~4~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
end
输出样例:
在这里给出相应的输出。例如：
2+2=~5~false
1+1=~22~false
0 0~0
输入样例5:
乱序输入。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
end
输出样例:
在这里给出相应的输出。例如：
3+2=~5~true
2+2=~22~false
70 0~70
输入样例6:
乱序输入+两份答卷。例如：
#N:3 #Q:3+2= #A:5
#N:2 #Q:2+2= #A:4
#T:1 3-70 2-30
#S:1 #A:5 #A:22
#N:1 #Q:1+1= #A:2
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
3+2=~5~true
2+2=~22~false
70 0~70
3+2=~5~true
2+2=~4~true
70 30~100
输入样例7:
乱序输入+分值不足100+两份答卷。例如：
#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
#S:1 #A:5 #A:4
end
输出样例:
在这里给出相应的输出。例如：
alert: full score of test paper1 is not 100 points
3+2=~5~true
2+2=~22~false
7 0~7
3+2=~5~true
2+2=~4~true
7 6~13
输入样例8:
乱序输入+分值不足100+两份答卷+答卷缺失部分答案。例如：
#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=~5~true
2+2=~22~false
7 0~7
2+2=~5~false
1+1=~4~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
分析题2目可知：
题目增加了：
1.三种信息可能会打乱顺序混合输入（将读取的数据存入String数组中）。
2.试卷号可输入多行数据（多张卷）题目分值不满100分要输出内容。
3.判分信息（输出分数）；
三个类如下代码：有错误在内
//问题类
public static class Question {
private int questionNumber;
private String questionContent;
private String standardAnswer;
private int Score;
public void setQuestionNumber(int questionNumber) {
this.questionNumber = questionNumber;
}
public void setQuestionScore(int Score) {
this.Score=Score;
}
public int getQuestionScore() {
return Score;
}
public int getQuestionNumber() {
return this.questionNumber;
}
public void setQuestionContent(String questionContent) {
this.questionContent = questionContent.trim();
}
public String getQuestionContent() {
return this.questionContent;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public String getStandardAnswer() {
return this.standardAnswer;
}
}
// 试卷类
public static class ExamPaper {
private int Scoresum=0;//记录一张试卷的总分
private int numQuestions=0;
private int examnumber;
private Question e[];//按题目1改
public void saveQuestion(int numQuestions, Question e[]) {
this.numQuestions=numQuestions;
this.e=new Question[numQuestions];
for(int i=0;i<numQuestions;i++)
{
this.e[i]=e[i];
}
for(int i=0;i<numQuestions-1;i++)
{
for(int j=0;j<numQuestions-i-1;j++)
{
if(this.e[j].questionNumber>this.e[j+1].questionNumber)
{
Question a=this.e[j];
this.e[j]=this.e[j+1];
this.e[j+1]=a;
}
}
}
}
public int getnum(){
return numQuestions;
}
public void setExamnumber(int examnumber) {
this.examnumber=examnumber;
}
public void setExamsum() {
for(int i=0;i<e.length;i++)
Scoresum=Scoresum+e[i].getQuestionScore();
}
public int GetExamsum() {
return Scoresum;
}
}
// 答卷类
public static class AnswerSheet {
private ExamPaper examPaper;//写一个hashmap(<Integer> exmNumber,<ExamPaper> examPaper);
private int ScoreA=0;//回答者的得分
private String questionAnther[];//按题目1改
private int i=0;//去掉
public AnswerSheet(ExamPaper examPaper) {
this.examPaper = examPaper;
}
public void saveAnswer(String answer1,int sort[]) {
if(questionAnther==null)
{
questionAnther=new String[20];
questionAnther[sort[i]-1]=answer1;
}
else
{
questionAnther[sort[i]-1]=answer1;
}
i++;
}
public int Geti(){
return i;
}
public void output(int sort[]) {
int a[]=new int [this.examPaper.getnum()];//记录得分情况也可以加到Question类中
for(int g=0;g<i;g++)
{
for(int k=0;k<i;k++)
{//改为一个循环mapQuestion.get(k).equal(mapAnther.get(k));
if(k+1==sort[g])
System.out.println(examPaper.e[k].questionContent+"~"+questionAnther[k]+"~"+examPaper.e[k].getStandardAnswer().equalsIgnoreCase(questionAnther[k]));
}
}
for(int j=0;j<i;j++)
{//mapQuestion.get(k).GetScore();
if(examPaper.e[j].getStandardAnswer().equalsIgnoreCase(questionAnther[j]))
{
ScoreA+=examPaper.e[j].getQuestionScore();
a[j]=examPaper.e[j].getQuestionScore();
}
}
if(this.examPaper.getnum()>i)
{
for(int k=0;k<this.examPaper.getnum()-i;k++)
{
System.out.println("answer is null");
}
}
for(int l=0;l<i;l++)
{
if(l!=i-1)
System.out.printf("%d ",a[l]);
else
System.out.printf("%d%c%d",a[l],'~',ScoreA);
}
}
}
改进2：
部分改进在代码中，hashmap中的key可以写成ArrayList类的集合减少循环次数；
List<String> returnResult2 = new LinkedList<String>();
Collection<String> values = map.values();
Iterator<String> it2 = values.iterator();
while(it2.hasNext()) {
returnResult2.add(it2.next());
}
完整代码2
有问题可自行更改仅供参考。
点击查看代码
import java.util.Scanner;
import java.util.regex.*;
public class Main {
public static void main(String[] args) {
Scanner p=new Scanner(System.in);
String e1=p.nextLine();
int sort[]=new int[10];
String []esum=new String [50];
Question a[]=new Question[20];
int i=0,k=0,j;
while(!e1.equals("end"))
{
esum[i]=e1;
e1=p.nextLine();
i++;
}
ExamPaper q=new ExamPaper();
for(j=0;j<i;j++)
{
Matcher matcher=Pattern.compile("#N:\\s*(\\d+)\\s*#Q:(.+)#A:(.+)").matcher(esum[j]);
if(matcher.find())
{
int questionNumber=Integer.parseInt(matcher.group(1));
String questionContent=matcher.group(2);
String questionAnther=matcher.group(3);
Question a1=new Question();
a1.setQuestionNumber(questionNumber);
a1.setQuestionContent(questionContent);
a1.setStandardAnswer(questionAnther);
a[k]=a1;
k++;
}
else
{
matcher=Pattern.compile("#T:(\\d+)\\s*(.+)").matcher(esum[j]);
if (matcher.find()){
q.setExamnumber(Integer.parseInt(matcher.group(1)));
String sum5[]=matcher.group(2).split("\\s");
for (int y=0;y<sum5.length;y++)
{
String []sum4=sum5[y].split("-");
int questionNumber=Integer.parseInt(sum4[0]);
sort[y]=questionNumber;
int Score=Integer.parseInt(sum4[1]);
for(int l=0;l<k;l++)
{
if(a[l].getQuestionNumber()==questionNumber)
{
a[l].setQuestionScore(Score);
}
}
}
j++;
break;
}
}
}
q.saveQuestion(k,a);
q.setExamsum();
if(q.GetExamsum()!=100)
{
System.out.println("alert: full score of test paper1 is not 100 points");
}
AnswerSheet o=new AnswerSheet(q);
AnswerSheet o1=new AnswerSheet(q);
int numg=0;
String questionAnther1;
for (int x=j;x<i;x++)
{
Matcher matcher=Pattern.compile("#S:\\s*(\\d+)\\s*(.+)").matcher(esum[x]);
if(matcher.find())
{
int examnumber=Integer.parseInt(matcher.group(1));
String ranges=matcher.group(2);
String[] Line=ranges.split("\\s+");
if(numg==0)
{
for(int c=0;c<Line.length;c++)
{
matcher=Pattern.compile("#A:(.+)").matcher(Line[c]);
if (matcher.find())
{
questionAnther1=matcher.group(1).trim();
o.saveAnswer(questionAnther1,sort);
}
}
}
else
{
for(int c=0;c<Line.length;c++)
{
matcher=Pattern.compile("#A:(.+)").matcher(Line[c]);
if (matcher.find())
{
questionAnther1=matcher.group(1).trim();
o1.saveAnswer(questionAnther1,sort);
}
}
}
}
}
o.output(sort);
if(o1.Geti()!=0)
o1.output(sort);
}
//问题类
public static class Question {
private int questionNumber;
private String questionContent;
private String standardAnswer;
private int Score;
public void setQuestionNumber(int questionNumber) {
this.questionNumber = questionNumber;
}
public void setQuestionScore(int Score) {
this.Score=Score;
}
public int getQuestionScore() {
return Score;
}
public int getQuestionNumber() {
return this.questionNumber;
}
public void setQuestionContent(String questionContent) {
this.questionContent = questionContent.trim();
}
public String getQuestionContent() {
return this.questionContent;
}
public void setStandardAnswer(String standardAnswer) {
this.standardAnswer = standardAnswer;
}
public String getStandardAnswer() {
return this.standardAnswer;
}
}
// 试卷类
public static class ExamPaper {
private int Scoresum=0;
private int numQuestions=0;
private int examnumber;
private Question e[];
public void saveQuestion(int numQuestions, Question e[]) {
this.numQuestions=numQuestions;
this.e=new Question[numQuestions];
for(int i=0;i<numQuestions;i++)
{
this.e[i]=e[i];
}
for(int i=0;i<numQuestions-1;i++)
{
for(int j=0;j<numQuestions-i-1;j++)
{
if(this.e[j].questionNumber>this.e[j+1].questionNumber)
{
Question a=this.e[j];
this.e[j]=this.e[j+1];
this.e[j+1]=a;
}
}
}
}
public int getnum(){
return numQuestions;
}
public void setExamnumber(int examnumber) {
this.examnumber=examnumber;
}
public void setExamsum() {
for(int i=0;i<e.length;i++)
Scoresum=Scoresum+e[i].getQuestionScore();
}
public int GetExamsum() {
return Scoresum;
}
}
// 答卷类
public static class AnswerSheet {
private ExamPaper examPaper;
private int ScoreA=0;
private String questionAnther[];
private int i=0;
public AnswerSheet(ExamPaper examPaper) {
this.examPaper = examPaper;
}
public void saveAnswer(String answer1,int sort[]) {
if(questionAnther==null)
{
questionAnther=new String[20];
questionAnther[sort[i]-1]=answer1;
}
else
{
questionAnther[sort[i]-1]=answer1;
}
i++;
}
public int Geti(){
return i;
}
public void output(int sort[]) {
int a[]=new int [this.examPaper.getnum()];
for(int g=0;g<i;g++)
{
for(int k=0;k<i;k++)
{
if(k+1==sort[g])
System.out.println(examPaper.e[k].questionContent+"~"+questionAnther[k]+"~"+examPaper.e[k].getStandardAnswer().equalsIgnoreCase(questionAnther[k]));
}
}
for(int j=0;j<i;j++)
{
if(examPaper.e[j].getStandardAnswer().equalsIgnoreCase(questionAnther[j]))
{
ScoreA+=examPaper.e[j].getQuestionScore();
a[j]=examPaper.e[j].getQuestionScore();
}
}
if(this.examPaper.getnum()>i)
{
for(int k=0;k<this.examPaper.getnum()-i;k++)
{
System.out.println("answer is null");
}
}
for(int l=0;l<i;l++)
{
if(l!=i-1)
System.out.printf("%d ",a[l]);
else
System.out.printf("%d%c%d",a[l],'~',ScoreA);
}
}
}
}
题目3
在答题判题程序-2基础上增补或者修改的内容，要求输入题目信息、试卷信息、答题信息、学生信息、删除题目信息，根据输入题目信息中的标准答案判断答题的结果。
分析题3目可知：
1.需要添加学生类。
2.删除题目信息要对应输出无该题。
3.输出形式的改变。
4.题目信息有错要判断并输出。
新类代码：
//学生类
public static class Student {
private String studentId;
private String name;
public Student(String studentId, String name) {
this.studentId = studentId;
this.name = name;
}
// 学号的getter方法
public String getStudentId() {
return studentId;
}
// 学号的setter方法
public void setStudentId(String studentId) {
this.studentId = studentId;
}
// 姓名的getter方法
public String getName() {
return name;
}
// 姓名的setter方法
public void setName(String name) {
this.name = name;
}
}
改进3：
可在原代码中用hashmap(key<String> StuId,value<Student> Stu);
来对应输入的学号对象；
对matcher读取的错误输入内容添加处理代码：
for(j=0;j<i;j++)
{
Matcher matcher=Pattern.compile("#N:\\s*(\\d+)\\s*#Q:(.+)#A:(.+)").matcher(esum[j]);
if(matcher.find())
{
int questionNumber=Integer.parseInt(matcher.group(1));
String questionContent=matcher.group(2);
String questionAnther=matcher.group(3);
Question a1=new Question();
a1.setQuestionNumber(questionNumber);
a1.setQuestionContent(questionContent);
a1.setStandardAnswer(questionAnther);
a[questionNumber]=a1;
k++;
}
else
{
matcher=Pattern.compile("#T:(\\d+)\\s*(.+)").matcher(esum[j]);
if (matcher.find()){
q.setExamnumber(Integer.parseInt(matcher.group(1)));
String sum5[]=matcher.group(2).split("\\s");
for (int y=0;y<sum5.length;y++)
{
String []sum4=sum5[y].split("-");
int questionNumber=Integer.parseInt(sum4[0]);
int Score=Integer.parseInt(sum4[1]);
if(a[questionNumber]!=null)
{
a[questionNumber].setQuestionScore(Score);
a[questionNumber].setState(true);
}
if(a[questionNumber]==null)
{
Question a1=new Question();
a[questionNumber]=a1;
a[questionNumber].setQuestionScore(Score);
a[questionNumber].setState(true);
}
}
j++;
break;
}
}
}
q.saveQuestion(k,a);
q.setExamsum();
AnswerSheet o=new AnswerSheet(q);
AnswerSheet o1=new AnswerSheet(q);
int numg=0;
String questionAnther1;
for (int x=j;x<i;x++)
{
Matcher matcher=Pattern.compile("#S:\\s*(\\d+)\\s*(.+)").matcher(esum[x]);
if(matcher.find())
{
int examnumber=Integer.parseInt(matcher.group(1));
String ranges=matcher.group(2);
String[] Line=ranges.split("\\s+");
if(numg==0)
{
for(int c=0;c<Line.length;c++)
{
matcher=Pattern.compile("#A:(.+)").matcher(Line[c]);
if (matcher.find())
{
String consist[]=matcher.group(1).split("-");
int antherNumber=Integer.parseInt(consist[0]);
questionAnther1=consist[1];
o.saveAnswer(questionAnther1,antherNumber);
}
}
}
else
{
for(int c=0;c<Line.length;c++)
{
matcher=Pattern.compile("#A:(.+)").matcher(Line[c]);
if (matcher.find())
{
String consist[]=matcher.group(1).split("-");
int antherNumber=Integer.parseInt(consist[0]);
questionAnther1=consist[1];
o1.saveAnswer(questionAnther1,antherNumber);
}
}
}
}
else
{
matcher=Pattern.compile("#X:\\s*(.+)\\s*").matcher(esum[x]);\\加的内容
if (matcher.find()){
String []osum=matcher.group(1).split("-");
for(int m=0;m<osum.length;m++)
{
String osum1[]=osum[m].split("\\s");
Student s1=new Student(osum1[0],osum1[1]);
Stu[Stunum]=s1;
Stunum++;
}
}
}
matcher=Pattern.compile("#D:N-(\\d+)\\s*").matcher(esum[x]);\\加的内容
if (matcher.find()){
int delenumber=Integer.parseInt(matcher.group(1));
o.examPaper.setErronum(delenumber);
}
}
总结
对于List类集合和hashmap和正则表达式和代码的可重用性可修改性都需要进一步学习与研究
学到了正则表达式的使用，大量处理数据的能力。
理解了Java类、对象、封装，以及如何使用这些概念来构建程序。
集合框架：学习Java的集合框架，如List、Map等接口及其实现类（如ArrayList、HashMap等），它们用于存储和管理多个对象。
学到了编写函数（方法）来封装复杂的逻辑，并学习常见的设计模式，以优化代码结构和提高可维护性。
掌握Java在eclipse中程序的测试与调试技巧，使用调试器逐步执行代码，检查变量的值，并定位和解决程序中的错误。
学习到Java编程语言的基本语法，包括变量声明、数据类型、运算符、条件语句（if-else）、循环语句（for, while）、数组等。