Java PTA第1~3次题目集总结

标签：输出 题目 String int 样例 System PTA Java 输入

一.前言

1.第一次题目集的知识点主要就是让我们初步意识到java与c语言不同的输入输出关键词用法以及一些相对固定的代码块（比如public static void main （String[] args）{}）；题量相对较多但在承受范围之内；难度较为简单。

2.第二次题目集的知识点除了跟第一次一样的之外，在7-1菜单题目里出现了类和对象的知识，在7-3日期题目里出现了导入包的知识；题量较少；难度相比于第一次急速上升。

3.第三次题目集的知识点涉及了数组排序、删除数组数据以及相关的ArrayList数组和对对象数据的封装和第二次题目集中出现过的导入包知识；题量跟第一次一样，相对较多；难度尽管没有第二次那么难，但总体上升了不少。

 

二.设计与分析

第一次题目集：

7-1 身体质量指数（BMI）测算 分数 10 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。

输入格式:

两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；

输出格式:

输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。

输入样例0:

在这里给出一组输入。例如：

-2  8

 

输出样例0:

在这里给出相应的输出。例如：

input out of range

 

输入样例1:

在这里给出一组输入。例如：

70 1.75

 

输出样例1:

在这里给出相应的输出。例如：

fit

  代码长度限制 20 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
double height=0;
double weight=0;
weight=in.nextDouble();
height=in.nextDouble();
if(height<=0||height>2.72||weight<=0||weight>727)
System.out.print("input out of range");
if(weight/(height*height)<18.5&&weight>0&&weight<=727&&height>0&&height<=2.72)
System.out.print("thin");
if(weight/(height*height)>=18.5&&weight/(height*height)<24&&weight>0&&weight<=727&&height>0&&height<=2.72)
System.out.print("fit");
if(weight/(height*height)>=24&&weight/(height*height)<28&&weight>0&&weight<=727&&height>0&&height<=2.72)
System.out.print("overweight");
if(weight/(height*height)>=28&&weight>0&&weight<=727&&height>0&&height<=2.72)
System.out.print("fat");
}
}

 

源码分析：

主要的运算逻辑和判断逻辑和c语言是一样的，所以编程时阻力不大，在了解java关键词以及导入需要的Scanner包就可以写出了

 

7-2 长度质量计量单位换算 分数 5 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

长度、质量的计量有多重不同的计算体系，有标准的国际单位制：千克与米，也有各个国家自己的计量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于0.0254米，请编写程序实现国际单位制与英制之间的换算。

输入格式:

两个浮点数，以空格分隔，第一个是质量（以千克为单位）、第二个是长度（以米为单位）。例如：0.45359237 0.0254。

输出格式:

两个浮点数，以空格分隔，第一个是质量（以磅为单位）、第二个是长度（以英寸为单位）。例如：1.0 1.0。

输入样例:

在这里给出一组输入。例如：

0.45359237 0.0254

 

输出样例:

在这里给出相应的输出。例如：

1.0 1.0

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
double pound=0;
double inch=0;
pound=in.nextDouble();
inch=in.nextDouble();
double kilogram=0;
double meter=0;
kilogram=pound/0.45359237;
meter=inch/0.0254;
System.out.print((float)kilogram+" "+(float)meter);
}
}

 

源码分析：

跟上一题差不多，主要的运算逻辑和判断逻辑和c语言是一样的，在了解java关键词以及导入需要的Scanner包就可以写出了

 

7-3 奇数求和 分数 9 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

计算一个数列中所有奇数的和。

输入格式:

十个整数，以空格分隔。例如：1 2 3 4 5 6 7 8 9 0。

输出格式:

输入数列中所有奇数之和。例如：25。

输入样例:

在这里给出一组输入。例如：

1 2 3 4 5 6 7 8 9 0

 

输出样例:

在这里给出相应的输出。例如：

25

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main{
public static void main(String[] args){
// int array[]=0;
Scanner in=new Scanner(System.in);
int sum=0;
int a=0,b=0,c=0,d=0,e=0,f=0,g=0,h=0,i=0,j=0;
a=in.nextInt();
if(a%2==0)
a=0;
b=in.nextInt();
if(b%2==0)
b=0;
c=in.nextInt();
if(c%2==0)
c=0;
d=in.nextInt();
if(d%2==0)
d=0;
e=in.nextInt();
if(e%2==0)
e=0;
f=in.nextInt();
if(f%2==0)
f=0;
g=in.nextInt();
if(g%2==0)
g=0;
h=in.nextInt();
if(h%2==0)
h=0;
i=in.nextInt();
if(i%2==0)
i=0;
j=in.nextInt();
if(j%2==0)
j=0;
sum=a+b+c+d+e+f+g+h+i+j;
System.out.print(sum);
}
}

源码分析：

跟前两题差不多，主要的运算逻辑和判断逻辑和c语言是一样的，在了解java关键词以及导入需要的Scanner包就可以写出了

 

7-4 房产税费计算2022 分数 12 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

房屋交易在日常生活中非常常见的事情，房屋交易时要额外支付各种税费，按2022年房产交易新政策的规定买房人应缴纳税费包括：

1、契税：首次购房评估额90平（含）内1%、90平-144平（含）内1.5%，超过144平或非首 次3%，买方缴纳。

2、印花税：房款的0.05%。

3、交易费：3元/平方米。

4、测绘费：1.36元/平方米。

5、权属登记费及取证费：一般情况是在200元内。

输入格式:

四个数据，以空格分隔：
1、第几次购房（整数）
2、房款（整数/单位万元）
3、评估价（整数/单位万元）
4、房屋面积（浮点数/单位平方米）。
例如：1 100 100 90。

输出格式:

契税、印花税、交易费、测绘费（以元为单位），以空格分隔。例如：10000.0 500.0 270.0 122.4

输入样例:

在这里给出一组输入。例如：

1 100 100 90

 

输出样例:

在这里给出相应的输出。例如：

10000.0 500.0 270.0 122.4

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
int frequency=in.nextInt();
int price=in.nextInt();
int guess=in.nextInt();
double area=in.nextDouble();
double stampDuty=0;
double transactionFee=0;
double mappingFee=0;
double deedTax=0;
if(frequency==1){
if(area > 144)
deedTax = price*0.03*10000;
else if(area > 90)
deedTax = price*0.015*10000;
else if(area > 0)
deedTax = price*0.01*10000;
}
else
deedTax = price*0.03*10000;
stampDuty = price * 0.0005 * 10000;
transactionFee = area * 3;
mappingFee = area * 1.36;
System.out.print((float)deedTax+" "+(float)stampDuty+" "+(float)transactionFee+" "+(float)mappingFee);
}
}

 

源码分析：

仍然跟前面题差不多，主要的运算逻辑和判断逻辑和c语言是一样的，在了解java关键词以及导入需要的Scanner包就可以写出了

 

7-5 游戏角色选择 分数 14 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

一款网游中包括4个种族：人类、精灵、兽人、暗精灵，每个种族包含三种角色：战士、法师、射手。玩家新建人物时需要选择种族和角色。请编写角色选择程序。

输入格式:

两个整数：游戏种族、角色的选项，以空格分隔。例如：1 2。
种族选项设定为：1、人类 2、精灵 3、兽人 4、暗精灵
角色选项设定为：1、战士 2、法师 3、射手

输出格式:

所选择的种族、角色的名称，以空格分隔。例如：人类 法师
若输入数值超出选项范围，输出“Wrong Format”

输入样例1:

在这里给出一组输入。例如：

1 2

 

输出样例1:

在这里给出相应的输出。例如：

人类 法师

 

输入样例2:

在这里给出一组输入。例如：

1 6

 

输出样例2:

在这里给出相应的输出。例如：

Wrong Format

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int race = in.nextInt();
int character = in.nextInt();
if((race<1)||(race>4)||(character<1)||(character>3))
System.out.print("Wrong Format");
else if(race==1&&character==1)
System.out.print("人类" + " " + "战士");
else if(race==1&&character==2)
System.out.print("人类" + " " + "法师");
else if(race==1&&character==3)
System.out.print("人类" + " " + "射手");
else if(race==2&&character==1)
System.out.print("精灵" + " " + "战士");
else if(race==2&&character==2)
System.out.print("精灵" + " " + "法师");
else if(race==2&&character==3)
System.out.print("精灵" + " " + "射手");
else if(race==3&&character==1)
System.out.print("兽人" + " " + "战士");
else if(race==3&&character==2)
System.out.print("兽人" + " " + "法师");
else if(race==3&&character==3)
System.out.print("兽人" + " " + "射手");
else if(race==4&&character==1)
System.out.print("暗精灵" + " " + "战士");
else if(race==4&&character==2)
System.out.print("暗精灵" + " " + "法师");
else if(race==4&&character==3)
System.out.print("暗精灵" + " " + "射手");
}
}

 

源码分析：

与前面题差不多，主要的运算逻辑和判断逻辑和c语言是一样的，在了解java关键词以及导入需要的Scanner包就可以写出了

 

7-6 学号识别 分数 10 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号

输入格式:

8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入

输出格式:

学号每一项的完整说明。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03

注意：如非法输入，输出“Wrong Format"

输入样例:

在这里给出一组输入。例如：

18011103

 

输出样例:

在这里给出相应的输出。例如：

入学年份：2018年
学院：材料学院
班级：11
学号：03

 

输入样例1:

在这里给出一组输入。例如：

18013

 

输出样例1:

在这里给出相应的输出。例如：

Wrong Format

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String num,nianFen,xueYuan,banJi,xueHao;
num = in.next();
if(num.length() != 8)
System.out.print("Wrong Format");
nianFen = num.substring(0,2);
xueYuan = num.substring(2,4);
banJi = num.substring(4,6);
xueHao = num.substring(6,8);
if(xueYuan.equalsIgnoreCase("01"))
xueYuan = "材料学院";
else if(xueYuan.equalsIgnoreCase("02"))
xueYuan = "机械学院";
else if(xueYuan.equalsIgnoreCase("03"))
xueYuan = "外语学院";
else if(xueYuan.equalsIgnoreCase("20"))
xueYuan = "软件学院";
else
System.out.print("Wrong Format");
System.out.println("入学年份：20"+nianFen+"年");
System.out.println("学院："+xueYuan);
System.out.println("班级："+banJi);
System.out.print("学号："+xueHao);
}

}

 

源码分析:

与前面题差不多，主要的运算逻辑和判断逻辑和c语言是一样的，在了解java关键词以及导入需要的Scanner包就可以写出了

 

7-8 巴比伦法求平方根近似值 分数 10 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

巴比伦法求n的近似值可以用以下公式：
nextGuess = (lastGuess+n/lastGuess)/2
程序初始运行时lastGuess可赋予一个最初的猜测值。当由公式求得的nextGuess和lastGuess相差较大时，把nextGuess的值赋给lastGuess，继续以上过程，直至nextGuess和lastGuess几乎相同，此时lastGuess或者nextGuess就是平方根的近似值。
本题要求：nextGuess和lastGuess的差值小于0.00001时认为两者几乎相同

输入格式:

1、两个浮点数，以空格分隔，第一个是n，第二个是lastGuess最初的猜测值。例如：2 1。
2、若输入的两个数中包含负数或者lastGuess初始输入为0，认定为非法输入

输出格式:

1、输出n的平方根近似值：lastGuess。例如：1.4142157
2、非法输入时输出："Wrong Format"

输入样例:

在这里给出一组输入。例如：

2 1

 

输出样例:

在这里给出相应的输出。例如：

1.4142157

 

输入样例1:

在这里给出一组输入1。例如：

2 -1

 

输出样例:

在这里给出相应的输出。例如：

Wrong Format

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
float n = in.nextFloat();
float lastGuess = in.nextFloat();
if(n<0||lastGuess<=0){
System.out.print("Wrong Format");
return;
}
float nextGuess=(lastGuess+n/lastGuess)/2;
while(Math.abs(nextGuess-lastGuess)>=0.00001){
lastGuess=nextGuess;
nextGuess=(lastGuess+n/lastGuess)/2;
}
System.out.print((float)lastGuess);
}

 

源码分析：

这题题目看起来有点吓人，因为出现了很多新奇的概念，但在仔细思考题目需求后发现逻辑是很简单的，然后主要以c语言的逻辑和java的框架完成此题

 

7-9 二进制数值提取 分数 10 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

在一个字符串中提取出其中的二进制数值序列，。

输入格式:

一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1

输出格式:

将输入的序列去掉非0、1字符以及结尾符的数据内容，
注：结束符-1之后的0\1字符忽略不计。
例如：00011。

输入样例:

在这里给出一组输入。例如：

abc00aj014421-1

 

输出样例:

在这里给出相应的输出。例如：

00011

 

输入样例1:

在这里给出一组输入。例如：

a0571-1k001y

 

输出样例1:

在这里给出相应的输出。例如：

01

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine();
String result = "";
for(int i=0;i<str.length();i++){
if(str.charAt(i)=='0'||str.charAt(i)=='1')
result += str.charAt(i);
else if(str.charAt(i)=='-' && str.charAt(i+1)=='1'){
System.out.print(result);
return;
}

}
System.out.print("Wrong Format");
}

}

 

源码分析：

这题主要逻辑跟之前一样吃c语言老本就行，不过涉及到了字符串的处理，也因此引出了java中字符串类的相关方法

 

7-7 判断三角形类型 分数 20 全屏浏览题目 切换布局 作者 段喜龙 单位 南昌航空大学

输入三角形三条边，判断该三角形为什么类型的三角形。

输入格式:

在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。

输出格式:

（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。

输入样例1:

在这里给出一组输入。例如：

50 50 50.0

 

输出样例1:

在这里给出相应的输出。例如：

Equilateral triangle

 

输入样例2:

在这里给出一组输入。例如：

60.2 60.2 80.56

 

输出样例2:

在这里给出相应的输出。例如：

Isosceles triangle

 

输入样例3:

在这里给出一组输入。例如：

0.5 20.5 80

 

输出样例3:

在这里给出相应的输出。例如：

Wrong Format

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
double a = in.nextDouble();
double b = in.nextDouble();
double c = in.nextDouble();
if(a<1||a>200||b<1||b>200||c<1||c>200)
System.out.println("Wrong Format");
else if(a+b<=c||a+c<=b||b+c<=a)
System.out.println("Not a triangle");
else if(a==b&&a==c&&b==c)
System.out.println("Equilateral triangle");
else if(a==b&&a*a+b*b-c*c<0.001)
System.out.println("Isosceles right-angled triangle");
else if(a==c&&a*a+c*c-b*b<0.001)
System.out.println("Isosceles right-angled triangle");
else if(c==b&&c*c+b*b-a*a<0.001)
System.out.println("Isosceles right-angled triangle");
else if(a==b||a==c||b==c)
System.out.println("Isosceles triangle");
else if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(c*c+b*b==a*a))
System.out.println("Right-angled triangle");
else
System.out.println("General triangle");
}

}

 

源码分析：

此题的逻辑仍比较简单，但体现出了java中的计算与c语言不同的地方，代码“a==b&&a*a+b*b-c*c<0.001”以及其他几行类似的代码都说明了java中的某些运算结果并不是我们想象中的数值，而是会去无限的接近这个数但不相等

 

 

第二次题目集：

7-1 菜单计价程序-1 分数 30 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

某饭店提供4种菜，每种菜品的基础价格如下：
西红柿炒蛋 15
清炒土豆丝 12
麻婆豆腐 12
油淋生菜 9

设计点菜计价程序，根据输入的订单，计算并输出总价格。
订单由一条或多条点菜记录组成，每条记录一行，最后以"end"结束
每条点菜记录包含：菜名、份额两个信息。
份额可选项包括：1、2、3，分别代表小、中、大份）

不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。
Dish {
String name;//菜品名称
int unit_price; //单价
int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
}

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。
Menu {
Dish[] dishs ;//菜品数组，保存所有菜品信息
Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
}

点菜记录类：保存订单上的一道菜品记录
Record {
Dish d;//菜品
int portion;//份额（1/2/3代表小/中/大份）
int getPrice()//计价，计算本条记录的价格
}

订单类：保存用户点的所有菜的信息。
Order {
Record[] records；//保存订单上每一道的记录
int getTotalPrice()//计算订单的总价
Record addARecord(String dishName,int portion)
//添加一条菜品信息到订单中。
}

输入格式:

每条点菜记录的格式：
菜名+空格（英文）+份额
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。
最后一条记录以“end”结束。

输出格式:

订单上所有菜品的总价（整数数值），每份菜
如果订单中包含不能识别的菜名，则在总价之前输出“** does not exist”，**是不能识别的菜名

输入样例:

在这里给出一组输入。例如：

麻婆豆腐 2
西红柿炒蛋 3
end

 

输出样例:

在这里给出相应的输出。例如：

48

 

输入样例1:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 2
炒脆肚 2
西红柿炒蛋 3
end

 

输出样例1:

在这里给出相应的输出。例如：

炒脆肚 does not exist
48

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   题目分析：

1. 类的设计与实现：需要设计并实现 Dish、Menu、Record 和 Order 这几个类来表示菜品、菜谱、点菜记录和订单。

2. 字符串操作：涉及菜品名称的存储、比较和解析。

3. 数组操作：在菜谱和订单中使用数组来保存多个菜品或点菜记录。

4. 循环和条件语句：用于在菜谱中查找菜品信息和计算订单总价。

5. 方法设计：每个类需要设计相应的方法来实现特定的功能，如计算菜品价格、查找菜品、计算点菜记录价格等。

6. 对象关联：类之间可能存在关联关系，如 Order 类中需要使用 Menu 类的方法来获取菜品信息。

7. 异常处理：需要处理无法识别的菜名，并显示错误信息。

8. 小数处理：根据要求，需要对价格进行四舍五入处理，可以使用 Math.round() 方法。

 

提交源码：

此题未做出，即源码为残缺的代码，此处就不展示了

 

7-2 菜单计价程序-2 分数 40 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

设计点菜计价程序，根据输入的信息，计算并输出总价格。

输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

菜单由一条或多条菜品记录组成，每条记录一行

每条菜品记录包含：菜名、基础价格 两个信息。

订单分：点菜记录和删除信息。每一类信息都可包含一条或多条记录，每条记录一行。
点菜记录包含：序号、菜名、份额、份数。
份额可选项包括：1、2、3，分别代表小、中、大份。

删除记录格式：序号 delete

标识删除对应序号的那条点菜记录。

不同份额菜价的计算方法：
小份菜的价格=菜品的基础价格。
中份菜的价格=菜品的基础价格1.5。
小份菜的价格=菜品的基础价格2。
如果计算出现小数，按四舍五入的规则进行处理。

参考以下类的模板进行设计：
菜品类：对应菜谱上一道菜的信息。

Dish {    
   String name;//菜品名称    
   int unit_price;    //单价    
   int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）    }

 

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

 

Menu {
   Dish[] dishs ;//菜品数组，保存所有菜品信息
   Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。
   Dish addDish(String dishName,int unit_price)//添加一道菜品信息
}

 

点菜记录类：保存订单上的一道菜品记录

 

Record {
   int orderNum;//序号\
   Dish d;//菜品\
   int portion;//份额（1/2/3代表小/中/大份）\
   int getPrice()//计价，计算本条记录的价格\
}

 

订单类：保存用户点的所有菜的信息。

Order {
   Record[] records；//保存订单上每一道的记录
   int getTotalPrice()//计算订单的总价
   Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。
   delARecordByOrderNum(int orderNum)//根据序号删除一条记录
   findRecordByNum(int orderNum)//根据序号查找一条记录
}

 

输入格式:

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete

最后一条记录以“end”结束。

输出格式:

按顺序输出每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后输出订单上所有菜品的总价（整数数值），

本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。

输入样例:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end

 

输出样例:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
63

 

输入样例1:

订单中包含删除记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end

 

输出样例1:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
27

 

输入样例2:

订单中包含不存在的菜品记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
end

 

输出样例2:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
63

 

输入样例3:

订单中包含删除信息以及不存在的菜品记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 delete
7 delete
end

 

输出样例3:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
27

 

输入样例4:

订单中包含删除信息以及不存在的菜品记录。例如：

麻婆豆腐 12
油淋生菜 9
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
end

 

输出样例4:

在这里给出相应的输出。例如：

1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
63

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   题目分析：

1. 类的设计与实现：需要实现 `Dish`、`Menu`、`Record` 和 `Order` 这几个类来表示菜品、菜谱、点菜记录和订单。

2. 字符串操作：包括菜名和删除指令的解析。

3. 数组操作：用于保存菜谱中的菜品和订单中的点菜记录。

4. 循环和条件语句：用于读取输入、处理订单和菜单。

5. 异常处理：处理无法识别的菜名和删除指令序号不存在的情况。

6. 方法设计：每个类需要设计相应的方法来实现特定的功能，如计算菜品价格、查找菜品、计算点菜记录价格、添加菜品到订单、删除订单中的记录等。

7. 小数处理：计算菜品价格时，需要进行四舍五入处理，可以使用 `Math.round()` 方法。

8. 订单的处理：根据输入的点菜记录和删除指令，对订单进行增加记录、删除记录和计算总价的操作。

9. 输出格式：按照要求输出每条点菜记录的处理信息，包括序号、菜名和价格；如果有不能识别的菜名则输出错误信息；最后输出订单的总价。

 

提交源码：

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);
Menu menu = new Menu();
Order order = new Order(menu);
String line = scanner.nextLine();
while (!line.equals("end"))
{
String[] lineArray = line.split(" ");

if (lineArray.length > 2)
{
int orderNum = Integer.parseInt(lineArray[0]);
String dishName = lineArray[1];
int portion = Integer.parseInt(lineArray[2]);
int num = Integer.parseInt(lineArray[3]);
order.addARecord(orderNum, dishName, portion, num);
}
else if ("delete".equals(lineArray[1]))
order.delARecordByOrderNum(Integer.parseInt(lineArray[0]));
else
menu.addDish(lineArray[0], Integer.parseInt(lineArray[1]));

line = scanner.nextLine();
}

System.out.println(order.getTotalPrice());
}
}

class Dish {
String name;//菜品名称
int unit_price; //单价

public String getName(){
return name;
}

public void setUnit_price(int unit_price){
this.unit_price = unit_price;
}

public Dish(String name, int unit_price)
{
this.name = name;
this.unit_price = unit_price;
}

//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
int getPrice(int portion) {
float b[] = {1, 1.5f, 2};
return Math.round((unit_price * b[portion - 1]));
}
}

class Menu
{
private List<Dish> dishs = new ArrayList<>();//菜品数组，保存所有菜品信息

void addDish(Dish dish) {
}

Menu() {

}

Dish searthDish(String dishName) {
for (Dish dish : dishs) {
if (dish.getName().equals(dishName)) {
return dish;
}
}
return null;
}

//添加一道菜品信息
Dish addDish(String dishName, int unit_price) {
for (Dish dish : dishs) {
if (dish.getName().equals(dishName)) {
dish.setUnit_price(unit_price);
return dish;
}
}
Dish dish = new Dish(dishName, unit_price);
dishs.add(dish);
return dish;
}
}

class Record {
private int orderNum;//序号\
private Dish d;//菜品\
private int portion;//份额（1/2/3代表小/中/大份）\
private int num;
private boolean isDelete = false;

public boolean isNotFound(){
return notFound;
}

public void setNotFound(boolean notFound){
this.notFound = notFound;
}

private boolean notFound = false;

public Record(Dish d, int portion) {
this.d = d;
this.portion = portion;
}

public Record(int orderNum, Dish d, int portion, int num) {
this.orderNum = orderNum;
this.d = d;
this.portion = portion;
this.num = num;
}

//计价，计算本条记录的价格
int getPrice(){
return d.getPrice(portion) * this.num;
}

public int getOrderNum(){
return orderNum;
}

public void setOrderNum(int orderNum){
this.orderNum = orderNum;
}

public Dish getD(){
return d;
}

public void setD(Dish d){
this.d = d;
}

public int getPortion(){
return portion;
}

public void setPortion(int portion){
this.portion = portion;
}

public boolean isDelete(){
return isDelete;
}

public void setDelete(boolean delete){
isDelete = delete;
}

public int getNum(){
return num;
}

public void setNum(int num){
this.num = num;
}

}

class Order {
private Menu menu;

private static List<Record> records = new ArrayList<>();//保存订单上每一道的记录

public Order(Menu menu){
this.menu = menu;
}

//计算订单的总价
int getTotalPrice() {
int sum = 0;
for (Record record : records)
{
int price = record.getPrice();
if (!record.isDelete())
sum = sum + price;
}

return sum;
}

//添加一条菜品信息到订单中。
Record addARecord(int orderNum, String dishName, int portion, int num) {
Dish dish = menu.searthDish(dishName);
if (dish == null) {
System.out.println(dishName + " does not exist");
return null;
}
Record record = new Record(orderNum, dish, portion, num);
records.add(record);
int price = record.getPrice();
System.out.println(record.getOrderNum() + " " + record.getD().getName() + " " + price);
return record;
}

public boolean delARecordByOrderNum(int orderNum) {
for (Record record : records) {
if (!record.isNotFound() && !record.isDelete() && record.getOrderNum() == orderNum) {
record.setDelete(true);
return true;
}
}
System.out.println("delete error;");
return false;
}
}

 

源码分析：

此题是在朋友的指导帮助下完成的，对其中很多代码块的功能相对模糊，不过对其中的for-each循环、ArrayList数组有了更深的了解。

 

7-3 jmu-java-日期类的基本使用 分数 15 全屏浏览题目 切换布局 作者 郑如滨 单位 集美大学

1. 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
2. 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、念书。

输入格式:

第一行输入一个日期字符串，格式为"YYYY-MM-dd"
第二行输入两个日期字符串，中间使用空格隔开。分别代表开始日期与结束日期。

输出格式:

如果第一行日期字符串非法，输出自定义的错误信息。
如果第一行日期有效，输出相关信息，如果是闰年要输出是闰年。
如果第二行两个日期，只要有一个无效。就输出相关错误信息。
如果第二行两个日期有效且结束日期不早于开始日期，输出相关信息。

输入样例1:

第一行日期非法、第二行有日期非法

2020-02-30
2020-02-30 2020-01-02

 

输出样例1:

2020-02-30无效!
2020-02-30或2020-01-02中有不合法的日期.

 

输入样例2:

均有效且合法

2021-02-28
2019-08-01 2020-01-02

 

输出样例2:

2021-02-28是当年第59天,当月第28天,当周第7天.
2020-01-02与2019-08-01之间相差154天,所在月份相差-7,所在年份相差1.

 

输入样例3:

日期均有效，但结束日期早于开始日期

2020-02-28
2020-02-02 2020-02-01

 

输出样例3:

2020-02-28是闰年.
2020-02-28是当年第59天,当月第28天,当周第5天.
2020-02-01早于2020-02-02,不合法!

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Main
{
public static int []month_day = {31,28,31,30,31,30,31,30,31,31,30,31};
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String date = in.next();
String start = in.next();
String end = in.next();
String date1 = number(date);
String start1 = number(start);
String end1 = number(end);
int date2 = Integer.parseInt(date1);
int start2 = Integer.parseInt(start1);
int end2 = Integer.parseInt(end1);
int dateDay = date2%100;
int dateMonth = date2/100%100;
int dateYear = date2/10000;
int startDay = start2%100;
int startMonth = start2/100%100;
int startYear = start2/10000;
int endDay = end2%100;
int endMonth = end2/100%100;
int endYear = end2/10000;
int judgeRun = runYear(dateYear);
if(judgeRun == 1) month_day[1] = 29;
int judgeLeg = judge_l(dateMonth,dateDay,date2);
if(judgeLeg==0)
System.out.println(date+"无效!");
else
{
if(judgeRun == 1)
System.out.println(date+"是闰年.");
int sum_day = daysOfYear(dateMonth, dateDay);
LocalDate startDate = LocalDate.of(2000,01,02);
LocalDate endDate = LocalDate.of(dateYear,dateMonth,dateDay);
long days = Math.abs(ChronoUnit.DAYS.between(startDate, endDate))%7;
if(days==0) days = 7;
System.out.println(date + "是当年第" + sum_day + "天,当月第" + dateDay + "天,当周第" + days+"天.");
}
judgeRun = runYear(startYear);
if(judgeRun == 0) month_day[1] = 28;
int judgeLegS = judge_l(startMonth,startDay,start2);
judgeRun = runYear(startYear);
if(judgeRun == 0) month_day[1] = 28;
if(judgeRun == 1) month_day[1] = 29;
int judgeLegE = judge_l(startMonth,startDay,end2);
if(judgeLegS==0||judgeLegE==0)
System.out.println(start + "或" + end + "中有不合法的日期.");
else if(start2>end2)
System.out.println(end+"早于"+start+",不合法!");
else
{
int yearSub = endYear - startYear;
int monthSub = endMonth - startMonth;
LocalDate startDate = LocalDate.of(startYear,startMonth,startDay);
LocalDate endDate = LocalDate.of(endYear,endMonth,endDay);
long days = ChronoUnit.DAYS.between(startDate, endDate);
System.out.print(end+"与"+start+"之间相差"+days+"天,所在月份相差"+monthSub+",所在年份相差"+yearSub+".");
}
}
public static String number(String str) //字符串转化为数字
{
str=str.trim();
String str2="";
if(str != null && !"".equals(str))
for(int i=0;i<str.length();i++)
if(str.charAt(i)>=48 && str.charAt(i)<=57)
str2+=str.charAt(i);
return str2;
}
public static int runYear(int year)//判断闰年
{
int run = 0;
if((0 == year % 4 && year % 100 != 0) || (0 == year % 400))
run = 1;
return run;
}
public static int daysOfYear(int month,int day)//当年的第几天
{
int sum=0;
for(int i=0;i<month-1;i++)
sum += month_day[i];
sum += day;
return sum;
}
public static int judge_l(int month,int day,int whole)
{
int judgement = 0;
if(whole<100000000&&whole>=10000000)
{
if (day >= 1 && day <= month_day[month - 1])
return judgement = 1;
else
return judgement = 0;
}else return judgement;

}
}

 

源码分析：

此题是第一次题目集中的日期题目的延伸，主要逻辑代码几乎都与导入的LocalDate包和temporal.ChronoUnit包有关

 

7-4 小明走格子 分数 15 全屏浏览题目 切换布局 作者 朱允刚 单位 吉林大学

从A点到B点有n个格子，小明现在要从A点到B点，小明吃了些东西，补充了一下体力，他可以一步迈一个格子，也可以一步迈两个格子，也可以一步迈3个格子，也可以一步迈4个格子。请编写程序计算小明从A点到B点一共有多少种走法。

输入格式:

输入包含多组数据，第一行为一个整数m，m不超过10000，表示输入数据组数。接下来m行，每行为一个整数n（保证对应的输出结果小于231），表示从A点到B点的格子数。

输出格式:

输出为m个整数，表示对于每组数据小明从A点到B点的走法数。

输入样例:

2
5
3

 

输出样例:

15
4

  代码长度限制 16 KB Java (javac) 时间限制 400 ms 内存限制 64 MB 其他编译器 时间限制 15 ms 内存限制 64 MB   提交代码：

此题未做出，即源码为残缺的代码，此处就不展示了

 

 

第三次题目集:

7-1 菜单计价程序-3 分数 30 全屏浏览题目 切换布局 作者 蔡轲 单位 南昌航空大学

设计点菜计价程序，根据输入的信息，计算并输出总价格。

输入内容按先后顺序包括两部分：菜单、订单，最后以"end"结束。

菜单由一条或多条菜品记录组成，每条记录一行

每条菜品记录包含：菜名、基础价格 两个信息。

订单分：桌号标识、点菜记录和删除信息、代点菜信息。每一类信息都可包含一条或多条记录，每条记录一行或多行。

桌号标识独占一行，包含两个信息：桌号、时间。

桌号以下的所有记录都是本桌的记录，直至下一个桌号标识。

点菜记录包含：序号、菜名、份额、份数。份额可选项包括：1、2、3，分别代表小、中、大份。

不同份额菜价的计算方法：小份菜的价格=菜品的基础价格。中份菜的价格=菜品的基础价格1.5。小份菜的价格=菜品的基础价格2。如果计算出现小数，按四舍五入的规则进行处理。

删除记录格式：序号 delete

标识删除对应序号的那条点菜记录。

如果序号不对，输出"delete error"

代点菜信息包含：桌号 序号 菜品名称 份额 分数

代点菜是当前桌为另外一桌点菜，信息中的桌号是另一桌的桌号，带点菜的价格计算在当前这一桌。

程序最后按输入的先后顺序依次输出每一桌的总价（注意：由于有代点菜的功能，总价不一定等于当前桌上的菜的价格之和）。

每桌的总价等于那一桌所有菜的价格之和乘以折扣。如存在小数，按四舍五入规则计算，保留整数。

折扣的计算方法（注：以下时间段均按闭区间计算）：

周一至周五营业时间与折扣：晚上（17：00-20：30）8折，周一至周五中午（10:30--14:30）6折，其余时间不营业。

周末全价，营业时间：9:30-21:30

如果下单时间不在营业范围内，输出"table " + t.tableNum + " out of opening hours"

参考以下类的模板进行设计：菜品类：对应菜谱上一道菜的信息。

Dish {

String name;//菜品名称

int unit_price; //单价

int getPrice(int portion)//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份） }

菜谱类：对应菜谱，包含饭店提供的所有菜的信息。

Menu {

Dish\[\] dishs ;//菜品数组，保存所有菜品信息

Dish searthDish(String dishName)//根据菜名在菜谱中查找菜品信息，返回Dish对象。

Dish addDish(String dishName,int unit_price)//添加一道菜品信息

}

点菜记录类：保存订单上的一道菜品记录

Record {

int orderNum;//序号\\

Dish d;//菜品\\

int portion;//份额（1/2/3代表小/中/大份）\\

int getPrice()//计价，计算本条记录的价格\\

}

订单类：保存用户点的所有菜的信息。

Order {

Record\[\] records；//保存订单上每一道的记录

int getTotalPrice()//计算订单的总价

Record addARecord(int orderNum,String dishName,int portion,int num)//添加一条菜品信息到订单中。

delARecordByOrderNum(int orderNum)//根据序号删除一条记录

findRecordByNum(int orderNum)//根据序号查找一条记录

}

### 输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

### 输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+”:”

2、按顺序输出当前这一桌每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价

本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+“:”+英文空格

2、按顺序输出当前这一桌每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价

本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求。

输入样例:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 12/2/3
1 麻婆豆腐 2 2
2 油淋生菜 1 3
end

 

输出样例:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 38

 

输入样例1:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 17/0/0
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end

 

输出样例1:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1: 22

 

输入样例2:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2023/3/22 16/59/59
1 麻婆豆腐 2 2
2 油淋生菜 1 3
1 delete
end

 

输出样例2:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
table 1 out of opening hours

 

输入样例3:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2022/12/5 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
5 delete
7 delete
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
7 delete
end

 

输出样例3:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
delete error;
table 2: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
delete error;
table 1 out of opening hours
table 2: 63

 

输入样例4:

在这里给出一组输入。例如：

麻婆豆腐 12
油淋生菜 9
table 1 2022/12/3 19/5/12
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
table 2 2022/12/3 15/03/02
1 麻婆豆腐 2 2
2 油淋生菜 1 3
3 麻辣鸡丝 1 2
1 4 麻婆豆腐 1 1
7 delete
end

 

输出样例4:

在这里给出相应的输出。例如：

table 1: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
table 2: 
1 麻婆豆腐 36
2 油淋生菜 27
麻辣鸡丝 does not exist
4 table 2 pay for table 1 12
delete error;
table 1: 63
table 2: 75

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交代码： 由于此题是前面菜单题目的延伸，而我对菜单题目的掌握度不够高，因而此题未完成，即代码为残缺代码，此处不设展示

 

7-2 有重复的数据 分数 10 全屏浏览题目 切换布局 作者 翁恺 单位 浙江大学

在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。

你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，输出“YES”这三个字母；如果没有，则输出“NO”。

输入格式:

你的程序首先会读到一个正整数n,n∈[1,100000]，然后是n个整数。

输出格式:

如果这些整数中存在重复的，就输出：

YES

 

否则，就输出：

NO

 

输入样例:

5
1 2 3 1 4

 

输出样例:

YES

  代码长度限制 16 KB 时间限制 800 ms 内存限制 64 MB   提交代码:

import java.util.Scanner;
public class Main{
public static void main(String[]args){
Scanner in=new Scanner(System.in);
int num=in.nextInt();
int []arry=new int[num];
int judegment=0;
for(int i=0;i<arry.length;i++)
{
arry[i]=in.nextInt();
}
if(num==1)
System.out.print("NO");
else
{
for(int k=0;k<arry.length;k++)
{
for(int t=k+1;t<=arry.length;t++)
{
if(arry[k]==arry[t])
{
System.out.print("YES");
judegment=-1;
break;
}

}
if(judegment==-1)
break;
}
if(judegment==0)
System.out.print("NO");
// else System.out.print("YES");

}

// for(int k:arry)
// {
// for(int t:arry)
// {
// if(k==t)
// {
// judegment=-1;
// }
// }
// }


}

}

 

源码分析：

主要逻辑代码比较简单，但此题最终的运算结果为部分正确，未通过的测试点显示“太快”，可能是算法比较落后导致运行时间略长，最终多次调试无果。

 

7-3 去掉重复的数据 分数 10 全屏浏览题目 切换布局 作者 翁恺 单位 浙江大学

在一大堆数据中找出重复的是一件经常要做的事情。现在，我们要处理许多整数，在这些整数中，可能存在重复的数据。

你要写一个程序来做这件事情，读入数据，检查是否有重复的数据。如果有，去掉所有重复的数字。最后按照输入顺序输出没有重复数字的数据。所有重复的数字只保留第一次出现的那份。

输入格式:

你的程序首先会读到一个正整数 n，1≤n≤100000。
然后是 n 个整数，这些整数的范围是 [1, 100000]。

输出格式:

在一行中按照输入顺序输出去除重复之后的数据。每两个数据之间有一个空格，行首尾不得有多余空格。

输入样例:

5
1 2 2 1 4

 

输出样例:

1 2 4

  代码长度限制 16 KB 时间限制 1500 ms 内存限制 150 MB   提交源码：

import java.util.Scanner;
import java.util.LinkedHashSet;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int num=in.nextInt();
LinkedHashSet<Integer> arry = new LinkedHashSet<Integer>();
for (int i = 0;i < num;i++)
{
arry.add(in.nextInt());
}
in.close();
int[] a = arry.stream().mapToInt(Integer::intValue).toArray();
for(int j=0;j<arry.size()-1;j++)
{
System.out.print(a[j] + " ");
}
System.out.print(a[arry.size()-1]);
}

}

 

源码分析：

此题需要导入一个LinkedHashSet包，以LinkedHashSet结合ArrayList方法可以很快做出此题

 

7-4 单词统计与排序 分数 15 全屏浏览题目 切换布局 作者 张峰 单位 山东科技大学

从键盘录入一段英文文本（句子之间的标点符号只包括“,”或“.”，单词之间、单词与标点之间都以" "分割。
要求：按照每个单词的长度由高到低输出各个单词（重复单词只输出一次），如果单词长度相同，则按照单词的首字母顺序（不区分大小写，首字母相同的比较第二个字母，以此类推）升序输出。

输入格式:

一段英文文本。

输出格式:

按照题目要求输出的各个单词（每个单词一行）。

输入样例:

Hello, I am a student from China.

 

输出样例:

student
China
Hello
from
am
a
I

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String str = in.nextLine().replaceAll("[,.]","");
String[] words = str.split(" ");
String string = "Jump out";
for(int i = 0;i<words.length-1;i++)
{
for(int j=0;j<words.length-1-i;j++)
{
if(words[j].length()<words[j+1].length())
{
String temp=words[j];
words[j]=words[j+1];
words[j+1]=temp;
}
else if(words[j].length()==words[j+1].length()) {
int result = words[j].compareToIgnoreCase( words[j+1] );
if(result>0) {
String a=words[j];
words[j]=words[j+1];
words[j+1]=a;
}
else if(result==0) {
words[j]=string;
}
}
}
}
for(int k=0;k<words.length;k++){
if(!words[k].equals(string))
System.out.println(words[k]);}
}
}

 

源码分析：

此题主要涉及String类及其相关方法

 

7-5 面向对象编程(封装性) 分数 10 全屏浏览题目 切换布局 作者 蒋辉 单位 天津仁爱学院

Student类具体要求如下：
私有成员变量：学号(sid，String类型)，姓名(name，String类型)，年龄(age，int类型)，专业(major，String类型) 。
提供无参构造和有参构造方法。（注意：有参构造方法中需要对年龄大小进行判定）
普通成员方法：print()，输出格式为“学号：6020203100，姓名：王宝强，年龄：21，专业：计算机科学与技术”。
普通成员方法：提供setXxx和getXxx方法。（注意：setAge()方法中需要对年龄进行判定）
注意：
年龄age不大于0，则不进行赋值。
print()中的“：”和“，”为均为中文冒号和逗号。

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //调用无参构造方法，并通过setter方法进行设值
        String sid1 = sc.next();
        String name1 = sc.next();
        int age1 = sc.nextInt();
        String major1 = sc.next();
        Student student1 = new Student();
        student1.setSid(sid1);
        student1.setName(name1);
        student1.setAge(age1);
        student1.setMajor(major1);
        //调用有参构造方法
        String sid2 = sc.next();
        String name2 = sc.next();
        int age2 = sc.nextInt();
        String major2 = sc.next();
        Student student2 = new Student(sid2, name2, age2, major2);
        //对学生student1和学生student2进行输出
        student1.print();
        student2.print();
    }
}

/* 请在这里填写答案 */

 

输入格式:

无

输出格式:

学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程

输入样例:

在这里给出一组输入。例如：

6020203110 王宝强 21 计算机科学与技术
6020203119 张三丰 23 软件工程

 

输出样例:

在这里给出相应的输出。例如：

学号：6020203110，姓名：王宝强，年龄：21，专业：计算机科学与技术
学号：6020203119，姓名：张三丰，年龄：23，专业：软件工程

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//调用无参构造方法，并通过setter方法进行设值
String sid1 = sc.next();
String name1 = sc.next();
int age1 = sc.nextInt();
String major1 = sc.next();
Student student1 = new Student();
student1.setSid(sid1);
student1.setName(name1);
student1.setAge(age1);
student1.setMajor(major1);
//调用有参构造方法
String sid2 = sc.next();
String name2 = sc.next();
int age2 = sc.nextInt();
String major2 = sc.next();
Student student2 = new Student(sid2, name2, age2, major2);
//对学生student1和学生student2进行输出
student1.print();
student2.print();
}
}

/* 请在这里填写答案 */

class Student{
private String sid;
private String name;
private int age;
private String major;

public Student()
{

};

public Student(String sid,String name,int age,String major){
super();
this.sid = sid;
this.name = name;
this.age = age;
this.major = major;
}

public String getSid(){
return this.sid;
}
public void setSid(String sid1){
this.sid = sid;
}

public String getName(){
return this.name;
}
public void setName(String name1){
this.name = name;
}

public int getAge(){
return this.age;
}
public void setAge(int age1){
this.age = age;
}

public String getMajor(){
return this.major;
}
public void setMajor(String major1){
this.major = major;
}

public void print(){
System.out.println("学号：" + sid + "，姓名：" + name + "，年龄：" + age + "，专业：" + major );
}

}

 

源码分析：

对对象属性的封装是该题涉及到的新的知识点，其他知识点基本都是之前出现过的，比如String类

 

7-6 GPS测绘中度分秒转换 分数 10 全屏浏览题目 切换布局 作者 周永 单位 西南石油大学

在测绘中，获取经度和纬度信息的时候，可以是度分秒格式，也可以是小数点格式。例如一个北纬的纬度信息，30°41′52.37″ ，可以转换为 30.697881。

规则：
(1)度和分都是整数，秒可以含有小数。将用户输入的第一个整数，加上第二个整数除以60，再加上第三个浮点数除以3600，就是最终结果。

(2)在输出结果时，保留6位小数。

(3)题目假定用户输入的数据，一定是合法的数据。

输入格式:

三个数值，数之间用空格分开。

输出格式:

见输出样例。

输入样例:

两个整数后，跟上一个小数。数据之间用空格分开。三个数分别代表度、分、秒。

30 41 52.37

 

输出样例:

输出经纬度信息的小数点格式，保留6位小数。
注意等号的前后有且仅有一个空格，建议复制下面输出到你的代码中，再进行修改。

30°41′52.37″ = 30.697881

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
public class Main{
public static void main(String[]args){
Scanner in=new Scanner(System.in);
int du=in.nextInt();
int fen=in.nextInt();
double miao=in.nextDouble();
double fuDian=du+fen/60.0+miao/3600.0;
System.out.print(du + "°" + fen + "′" + miao + "″ = " +String.format("%.6f",fuDian));
}
}

 

源码分析：

此题逻辑很简单，也没有涉及什么java知识点，只用c语言的语法逻辑便可以完成此题

 

7-7 判断两个日期的先后，计算间隔天数、周数 分数 15 全屏浏览题目 切换布局 作者 吴光生 单位 新余学院

从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。

预备知识：通过查询Java API文档，了解Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法，了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则，了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法。

输入格式:

输入两行，每行输入一个日期，日期格式如：2022-06-18

输出格式:

第一行输出：第一个日期比第二个日期更早（晚）
第二行输出：两个日期间隔XX天
第三行输出：两个日期间隔XX周

输入样例1:

2000-02-18
2000-03-15

 

输出样例1:

第一个日期比第二个日期更早
两个日期间隔26天
两个日期间隔3周

 

输入样例2:

2022-6-18
2022-6-1

 

输出样例2:

第一个日期比第二个日期更晚
两个日期间隔17天
两个日期间隔2周

  代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB   提交源码：

import java.util.Scanner;
import java.time.*;
import java.time.temporal.ChronoUnit;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String time1 = in.nextLine();
String time2 = in.nextLine();
String []split1 = time1.split("-");
String []split2 = time2.split("-");
LocalDate date1 = LocalDate.of(Integer.parseInt(split1[0]), Integer.parseInt(split1[1]), Integer.parseInt(split1[2]));
LocalDate date2 = LocalDate.of(Integer.parseInt(split2[0]), Integer.parseInt(split2[1]), Integer.parseInt(split2[2]));
if(date1.isAfter(date2)){
System.out.println("第一个日期比第二个日期更晚");
System.out.println("两个日期间隔" + ChronoUnit.DAYS.between(date2,date1) + "天");
System.out.print("两个日期间隔" + ChronoUnit.WEEKS.between(date2,date1) + "周");
}
else{
System.out.println("第一个日期比第二个日期更早");
System.out.println("两个日期间隔" + ChronoUnit.DAYS.between(date1,date2) + "天");
System.out.print("两个日期间隔" + ChronoUnit.WEEKS.between(date1,date2) + "周");
}

}

}

 

源码分析：

此题需要导入temporal.ChronoUnit包才方便解决，不然代码会非常长且低效。

 

 

三.遇到的困难和改进建议

（1）7-3 jmu-java-日期类的基本使用

1. 给定一个日期，判定是否为合法日期。如果合法，判断该年是否闰年，该日期是当年第几天、当月第几天、当周第几天、。
2. 给定起始日期与结束日期，判定日期是否合法且结束日期是否早于起始日期。如果均合法，输出结束日期与起始日期之间的相差的天数、月数、年数。

在该题处，运用了jmu-java-日期类。但是我还没有学过、见过该类的使用，看到题目时毫无头绪。不过通过上网查询资料并学习参考代码，才勉强能够照样读取处理日期数据。  （2）在编写菜单题目的代码时，由于题目给的有点突然以及自学不及时，导致对该题涉及到的最重要的类和对象知识点不清楚，以至于在编写时毫无头绪最终不得不放弃 （3）用Java编写程序，从键盘输入两个日期，格式如：2022-06-18。判断两个日期的先后，并输出它们之间间隔的天数、周数（不足一周按0计算）。 1.输入两行，每行输入一个日期，日期格式如：2022-06-18 2.第一行输出：第一个日期比第二个日期更早（晚） 第二行输出：两个日期间隔XX天 第三行输出：两个日期间隔XX周 我使用Scanner类从键盘读取用户输入的两个日期，使用Java 8中的LocalDate类将日期字符串转换为日期对象，并使用ChronoUnit类计算两个日期之间的天数。

最后，通过判断第一个日期是否早于第二个日期来输出它们的先后关系，并输出它们之间的天数和周数（使用整除运算符将天数转换为周数）

 

 

四.总结

　　通过这几次题目集，我构成了一定的java思维，不再依靠c语言的基础去编写java的题目，我也意识到java面向对象编程和c语言面向过程编程的区别和各自的优缺点。建议就是希望老师能在每次作业截止之后及时把答案发出来给同学们参考并及时公布每次作业各个测试点的详细信息，让学生能更好的查缺补漏提升自己而不是仅且仅当各次题目当成一个截止了就不用管的题目

 

标签：输出,题目,String,int,样例,System,PTA,Java,输入
From： https://www.cnblogs.com/gxorgyjj/p/17429821.html