首页 > 其他分享 >小结

小结

时间：2023-10-07 11:57:16浏览次数：31  
标签：java String int System 小结 public out

PTA题目集1-3总结

一.前言

知识点：

题目集1

使用java基本语法解决相应简单问题，相应的输入输出，对精度和格式的正确使用

题目集2

学会对象的创建，类的构造方法，一些方法的调用

题目集3

日期类的使用，以及一些类之间关系的构造，一些常用工具类的使用，对封装和继承，多态的了解

题量

第一次作业： 

  身体质量指数（BMI）测算   长度质量计量单位换算   NCHU_奇数求和  NCHU_房产税费计算  游戏角色选择

  NCHU_学号识别   NCHU_巴比伦法求平方根近似值  二进制数值提取   判断三角形类型

第二次作业：

成绩计算-1-类、数组的基本运用  成绩计算-2-关联类   有重复的数据   去掉重复的数据   面向对象编程(封装性)  GPS测绘中度分秒转换   菜单计价程序-1  jmu-java-日期类的基本使用

第三次作业：

jmu-java-日期类的基本使用   课程成绩统计程序-1   面向对象编程(封装性)    判断两个日期的先后，计算间隔天数、周数

难度情况

第一次作业总体偏易，第二次作业  成绩计算-2-关联类 jmu-java-日期类的基本使用较难，第三次作业课程成绩统计程序-1特难

二、设计与分析

题目集1

 

7-1 身体质量指数（BMI）测算

体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，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”。

 

主要使用if 分支语句完成判断，第一题相对简单

 

代码如下

 

import java.util.*;
public class Main{
public static void main(String[]args){
Scanner indata = new Scanner(System.in);
Double Kg =indata.nextDouble();
Double Km =indata.nextDouble();
Double bim =  Kg/(Km*Km);
if(Kg<0||Kg>=727||Km<0||Km>=2.72){
System.out.println("input out of range");
}
else{
if(bim<18.5){
System.out.println("thin");
}
if(bim>=18.5&&bim<24){
System.out.println("fit");
}
if(bim>=24&&bim<28){
System.out.println("overweight");
}
if(bim>=28){
System.out.println("fat");
}
}
}
}
7-2 长度质量计量单位换算  

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

输入格式:

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

输出格式:

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

 

该题提交了很多遍，最终发现是精度问题，结果输出的值一定要用float类型，不能使用double。不然测试点过不去

import java.util.*;
public class Main{
public static void main(String[]args)
{
Scanner indata = new Scanner(System.in);
double kg = indata.nextDouble();
double km = indata.nextDouble();
double g =0.45359237;
double m = 0.0254;
kg=kg/g;
km=km/m;
System.out.print((float)kg+" "+(float)km);
}
}
7-3 NCHU_奇数求和  

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

输入格式:

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

输出格式:

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

 

 

主要是在for循环中判断是否为奇数，如果是则加入总数

import java.util.*;
public class Main{
public static void main(String[]args)
{
    Scanner indata = new Scanner(System.in);
    int add = 0;
    for(int i = 0;i<10;i++){
        int data = indata.nextInt();
        if(data%2==1||data%2==-1)
        add = add+ data;
    }
    System.out.print(add);
}
}
7-4 NCHU_房产税费计算

房屋交易在日常生活中非常常见的事情，房屋交易时要额外支付各种税费，按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

 

改题主要是搞清楚不同情况下费用计算的逻辑，并以float格式输出

import java.util.*;
public class Main{
   public static void main(String[]args)
   {
    Scanner indata = new Scanner(System.in);
    int n =indata.nextInt();
    int money = 10000*indata.nextInt();
    int premoney = 10000*indata.nextInt();
    double sq = indata.nextDouble();
    if(n==1)
    {
        if(sq>=0&&sq<=90)
        {System.out.print((float)(money*0.01)+" "+(float)(money*0.0005)+" "+(float)(sq*3)+" "+(float)(sq*1.36));}
        if(sq>90&&sq<=144)
        {System.out.print((float)(money*0.015)+" "+(float)(money*0.0005)+" "+(float)(sq*3)+" "+(float)(sq*1.36));}
        if(sq>144)
        {System.out.print((float)(money*0.03)+" "+(float)(money*0.0005)+" "+(float)(sq*3)+" "+(float)(sq*1.36));}
    }
    else
    {System.out.print((float)(money*0.03)+" "+(float)(money*0.0005)+" "+(float)(sq*3)+" "+(float)(sq*1.36));}
       
   }
}
7-5 游戏角色选择  

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

输入格式:

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

输出格式:

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

 

该题使用了if中嵌套if来解决问题，还可以使用switch来解决

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

}
7-6 NCHU_学号识别

学校的学号由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"

 

该题主要使用了substring对数字进行分割，也可以使用parseInt来拆包。以及使用.equals进行内容对比,最初使用==，查阅资料后发现==并不能实现该功能，该题目的判断也可以使用正则表达式来解决。

import java.util.*;
public class Main{
public static void main(String[]args)
   {
       Scanner indata = new Scanner(System.in);
       String num = indata.next();
       if(num.length()!=8)
       {
           System.out.print("Wrong Format");
           return;
        }
        String y = num.substring(0,2);
        String x = num.substring(2,4);
        String xx = "";
        String bj = num.substring(4,6);
        String xh = num.substring(6,8);  
        if(x.equals("01"))
          xx="材料学院";
        else if(x.equals("02"))
          xx="机械学院";
         else if(x.equals("03"))
          xx="外语学院";
         else if(x.equals("20"))
          xx="软件学院";
        else
        {
            System.out.print("Wrong Format");
            return;
        }

System.out.println("入学年份：20"+y+"年");
System.out.println("学院："+xx);
System.out.println("班级："+bj);
System.out.print("学号："+xh);
                   }
 }
7-8 NCHU_巴比伦法求平方根近似值  

巴比伦法求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"

该题主要在逻辑判断以及基本语法的使用

import java.util.*;
public class Main{
    public static void main(String[]args)
    {
        Scanner indata = new Scanner(System.in);
        float nextGuess=0;
        float n= indata.nextFloat();
        float lastGuess = indata.nextFloat();
        if(n<=0||lastGuess<=0){
            System.out.print("Wrong Format");
            return;
        }
        while(true){
            nextGuess =(float)( (lastGuess+n/lastGuess)/2.0);
            if(nextGuess-lastGuess<=-0.00001||nextGuess-lastGuess>=0.00001)
            {
                lastGuess = nextGuess;
    
            }else{
                System.out.print((float)lastGuess);
                return;
            }
        }
        
    }
}
7-9 二进制数值提取

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

输入格式:

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

输出格式:

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

 

该题学会了charAT的使用将String中的每一位转换成字符型进行判断

import java.util.*;
public class Main{
public static void main(String[]args)
   {
     Scanner indata = new Scanner(System.in);
    String s = indata.nextLine();
    String ss = "";
    int ok = 0;
    for(int i =0;i<s.length();i++)
    {
        char x =s.charAt(i);
        if(x=='0'||x=='1')
        ss+=x;
        if(x=='-')
        {
             ok=1;
            break;
        } 
        
    }
     if(ok!=1){
              System.out.println("Wrong Format");
              return;
           }
    System.out.println(ss);
 }
}
7-7 判断三角形类型

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

输入格式:

在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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”。

 

该题难在等腰直角三角形的判断，由于精度的影响不能使用两边的平方等于斜边的平方和，只能判断差值是否在一个范围内，不然无法通过该测试点

import java.util.*;
public class Main{
public static void main(String[]args){
    Scanner indata = new Scanner(System.in);
    double fir = indata.nextDouble();
    double sec = indata.nextDouble();
    double thi = indata.nextDouble();
   
    if(fir<1||fir>200||sec<1||sec>200||thi<1||thi>200){
        System.out.println("Wrong Format");
        return;
    }
     if(fir>=(sec+thi)||sec>=(fir+thi)||thi>=(fir+sec))
    {
        System.out.println("Not a triangle");
        return;
    }
    else{
        if(fir == sec &&sec==thi &&fir==thi){
            System.out.print("Equilateral triangle");
            return;
        }
        else if((((thi*thi-fir*fir+sec*sec)<=10e-7&&(thi*thi-fir*fir+sec*sec)>=-10e-7)||((thi*thi+fir*fir-sec*sec)<=10e-7&&(thi*thi+fir*fir-sec*sec)>=-10e-7)||((-thi*thi+fir*fir+sec*sec)<=10e-7)&&(-thi*thi+fir*fir+sec*sec)>=-10e-7)&&(fir == sec ||sec==thi ||fir==thi))
        {
            System.out.print("Isosceles right-angled triangle");
            return;
        }
        else if((thi*thi==(fir*fir)+(sec*sec)||fir*fir==(thi*thi)+(sec*sec)||sec*sec==(thi*thi)+(fir*fir))&&(fir != sec &&sec!=thi &&fir!=thi))
        {
            System.out.print("Right-angled triangle");
            return;
        }
        else if((thi*thi!=(fir*fir)+(sec*sec)&&fir*fir!=(thi*thi)+(sec*sec)&&sec*sec!=(thi*thi)+(fir*fir))&&(fir == sec ||sec==thi ||fir==thi))
        {
            System.out.print("Isosceles triangle");
            return;
        }
        else
        {
            System.out.print("General triangle");
            return;
        }
    }
}

}

题目集2

7-1 成绩计算-1-类、数组的基本运用

创建学生类，包含

属性：学号（String）、姓名（String）、语文成绩（int）、数学成绩（int）、物理成绩（int）

方法：计算总分、计算平均分

输入5个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出5个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：
https://blog.csdn.net/huaishuming/article/details/17752365


注意：未用学生类对象封装数据的，本题计0分

输入格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+语文成绩+英文空格+数学成绩+英文空格+物理成绩
例如：
22201311 张琳 80 80 80

22201312 黄昊 66 82 81

22201313 李少辰 77 76 80

22201314 袁婷 62 79 90

22201315 朱哲一 74 98 94

输出格式:

5个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：

22201311 张琳 240 80.00

22201312 黄昊 229 76.33

22201313 李少辰 233 77.67

22201314 袁婷 231 77.00

22201315 朱哲一 266 88.67

 

该题是第一次使用类的创建，使用了封装特性，用private封装了私有属性以及使用提供的get，set方法来控制这些变量，并使用DecimalFormat来控制输出格式，本题较为简单

import java.util.*;
import java.text.DecimalFormat;

class Student{
    private String ID;
    private String name;
    private int ch;
    private int ma;
    private int py;

    public int total (){
        return ch +ma +py;
    }
    public double ave(){
        double ave = (ch+ma+py)/(3.0);
        return ave;
    }
    public void setID(String ID){
        this.ID= ID;
    }
    public void setName(String name){
        this.name= name;
    }
     public void setch(int ch){
        this.ch= ch;
    }
    public void setma(int ma){
        this.ma= ma;
    }
    public void setpy(int py){
        this.py= py;
    }
    
    public String getID() {
        return ID;
    }

    public String getName(){
        return name;
    }

    public int getch() {
        return ch;
    }

    public int getma() {
        return ma;
    }

    public int getpy() {
        return py;
    }

}
public class Main{
    public static void main(String[]args)
    {
        Scanner indata = new Scanner(System.in);
        Student[] stus = new Student[5];
        for(int i =0;i<5;i++){
            stus[i]= new Student();
            stus[i].setID(indata.next());
            stus[i].setName(indata.next());
            stus[i].setch(indata.nextInt());
            stus[i].setma(indata.nextInt());
            stus[i].setpy(indata.nextInt());
        }
        DecimalFormat df = new DecimalFormat("#.00");
        
         for(int i = 0;i<5;i++){
            System.out.println(stus[i].getID()+" "+stus[i].getName()+" "+stus[i].total()+" "+df.format(stus[i].ave()));
        }
        
        
    }

    
}

 

  7-2 成绩计算-2-关联类（重点）  

属性：平时成绩（int）、期末成绩（int）

方法：计算总成绩（计算规则：平时成绩*0.4+期末成绩*0.6，保留整数部分，小数部分直接丢弃）

创建学生类，包含：

属性：学号（String）、姓名（String）、语文成绩（成绩类）、数学成绩（成绩类）、物理成绩（成绩类）

方法：计算总分、计算平均分

输入3个学生的信息，将每个学生的信息封装在一个学生对象中。

按输入顺序依次输出3个学生的总分、平均分（精确到小数点后两位，舍去部分按四舍五入规则计入最后一位）。

浮点数保留小数的相关知识可参考：https://blog.csdn.net/huaishuming/article/details/17752365


注意：未用学生类对象封装数据的，本题计0分

输入格式:

依次输入3个学生的每门课成绩，每个学生成绩信息格式：

学号+英文空格+姓名+英文空格+课程名+英文空格+平时成绩+英文空格+期末成绩
注：3个学生的课程顺序可能会不一致

例如：
22201311 张琳 语文 70 80

22201311 张琳 数学 85 89

22201311 张琳 物理 75 83

22201312 黄昊 语文 66 78

22201312 黄昊 数学 76 82

22201312 黄昊 物理 83 82

22201313 李少辰 语文 86 76

22201313 李少辰 数学 78 76

22201313 李少辰 物理 87 76

输出格式:

3个学生信息，每个学生信息格式：

学号+英文空格+姓名+英文空格+总成绩+英文空格+平均分

例如：


22201311 张琳 242 80.67

22201312 黄昊 234 78.00

22201313 李少辰 236 78.67

本题延续上题风格，但难在数据输入格式的判断上，使用.equal来判断不同学科给不同学科属性赋值是关键

 

详细思路：

定义了两个类：Score和Student。Score类表示一个学生的成绩，包括语文、数学和物理的成绩。Student类表示一个学生，包括学生的学号、姓名和成绩。

在主函数中，首先创建了一个Scanner对象用于读取输入数据，并创建了一个DecimalFormat对象用于格式化输出结果。

然后，创建了一个长度为3的Student数组和一个长度为3的Score数组。

接下来，使用循环读取输入数据，并将数据存储在相应的Student和Score对象中。

最后，输出每个学生的学号、姓名、总分、语文平均分、数学平均分和物理平均分。

使用面向对象的思想，将学生和成绩的数据封装在不同的类中，使得代码更加清晰和易于理解。同时，使用了数组和循环来处理多个学生的数据，提高了代码的灵活性和可扩展性。

import java.util.*;
import java.text.DecimalFormat;
 class Score{
    private int norsc;
    private int endsc;
    public int getNorsc() {
        return norsc;
    }

    public void setNorsc(int norsc) {
        this.norsc = norsc;
    }

    public int getEndsc() {
        return endsc;
    }

    public void setEndsc(int endsc) {
        this.endsc = endsc;
    }
    public int total(){
        double to =0;
        to = 0.4*norsc+0.6*endsc;
        return (int)to;
    }
    
}
 class Student{
    private String id;
    private String name;
    private Score ch;
    private Score ma;
    private Score py;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Score getCh() {
        return ch;
    }

    public void setCh(Score ch) {
        this.ch = ch;
    }

    public Score getMa() {
        return ma;
    }

    public void setMa(Score ma) {
        this.ma = ma;
    }

    public Score getPy() {
        return py;
    }

    public void setPy(Score py) {
        this.py = py;
    }



    public int total (){
        return ch.total() +ma.total() +py.total();
    }
    public double ave(){
        double ave = (ch.total()+ma.total()+py.total())/(3.0);
        return ave;
    }
    public double avenor(){
        return (ch.getNorsc() +ma.getNorsc() +py.getNorsc())/3.0;
    }
    public double aveend(){
        return (ch.getEndsc() +ma.getEndsc() +py.getEndsc())/3.0;
    }
    
}
public class Main{
    public static void main(String[]args)
    {
        DecimalFormat df = new DecimalFormat("#.00");
        Scanner indata = new Scanner(System.in);
        Student[] stus = new Student[3];
        Score[] scores = new Score[3];
        for(int i=0;i<3;i++)
        {
            stus[i] = new Student();


            stus[i].setId(indata.next());
            stus[i].setName(indata.next());
            String a =indata.next();
            if(a.equals("语文")){
                scores[i] = new Score();
            scores[i].setNorsc(indata.nextInt());
            scores[i].setEndsc(indata.nextInt());
            stus[i].setCh(scores[i]);

            }
            if(a.equals("数学")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setMa(scores[i]);

            }
            if(a.equals("物理")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setPy(scores[i]);

            }
            String id1=indata.next();
            String n1=indata.next();
            String b =indata.next();
            if(b.equals("语文")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setCh(scores[i]);

            }
            if(b.equals("数学")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setMa(scores[i]);

            }
            if(b.equals("物理")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setPy(scores[i]);

            }
            String id2=indata.next();
            String n2=indata.next();
            String c =indata.next();
            if(c.equals("语文")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setCh(scores[i]);
            }
            if(c.equals("数学")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setMa(scores[i]);
            }
            if(c.equals("物理")){
                scores[i] = new Score();
                scores[i].setNorsc(indata.nextInt());
                scores[i].setEndsc(indata.nextInt());
                stus[i].setPy(scores[i]);
            }



        }
        System.out.println(stus[0].getId()+" "+stus[0].getName()+" "+stus[0].total()+" "+df.format(stus[0].avenor())+" "+df.format(stus[0].aveend())+" "+df.format(stus[0].ave()));
        System.out.println(stus[1].getId()+" "+stus[1].getName()+" "+stus[1].total()+" "+df.format(stus[1].avenor())+" "+df.format(stus[1].aveend())+" "+df.format(stus[1].ave()));
        System.out.println(stus[2].getId()+" "+stus[2].getName()+" "+stus[2].total()+" "+df.format(stus[2].avenor())+" "+df.format(stus[2].aveend())+" "+df.format(stus[2].ave()));






    }
}

 

  7-3 有重复的数据

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

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

输入格式:

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

输出格式:

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

YES

否则，就输出：

NO
该题如果使用两个for循环来暴力解题会超时，可以使用java自带的Arrays.sort进行排序然后再判断后面数字是否和前面相同即可，可以将复杂度变成O(nlogn)
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner indata = new Scanner(System.in);
        int n = indata.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = indata.nextInt();
        }
        Arrays.sort(arr);
        for (int i = 1; i < n; i++) {
            if (arr[i] == arr[i-1]) {
                System.out.println("YES");
                return;
            }
        }
        
        System.out.println("NO");
    }
}
7-4 去掉重复的数据  

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

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

输入格式:

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

输出格式:

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

 

该题和上题大题相似，暴力解会超时，可以使用hashSet来解决问题

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner indata = new Scanner(System.in);
        int n = indata.nextInt();
        Set<Integer> set = new HashSet<>();
        StringBuilder out = new StringBuilder();
        for (int i = 0; i < n; i++) {
            int z = indata.nextInt();
            if (!set.contains(z)) {
                set.add(z);
                 out.append(z).append(" ");
                }
            }
        out.setLength(out.length()-1);
        System.out.println(out);
        }
    
}
  7-5 面向对象编程(封装性)

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，专业：软件工程

 

该题主要考察类中属性和方法的构建，并无难度

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       
        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.print();
        student2.print();
    }
}
class Student{
    private String sid;
    private String name;
    private int age;
    private String major;
    public String getSid(){
        return sid;
    }
    public void setSid(String sid){
        this.sid = sid;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age > 0)
            this.age = age;
        else 
            this.age = 0;
    }
    public String getMajor(){
        return major;
    }
    public void setMajor(String major){
        this.major = major;
    }
    public Student(){}
    public Student(String sid, String name,int age,String major)
{
        this.sid = sid;
        this.name = name;
        if(age>0)
            this.age = age;
        else
            this.age = 0;
        this.major = major;
}
    public void print()
    {
        System.out.println("学号："+sid+"，姓名："+name+"，年龄："+age+"，专业："+major);
    }
    
 }
7-6 GPS测绘中度分秒转换

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

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

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

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

输入格式:

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

输出格式:

见输出样例。

输入样例:

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

30 41 52.37

输出样例:

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

30°41′52.37″ = 30.697881



本题较为简单，主要是精度输出的考察
import java.util.*;
import java.text.DecimalFormat;
public class Main{
    public static void main(String[]args){
    DecimalFormat f = new DecimalFormat("#.000000");
    Scanner indata = new Scanner(System.in);
    int dushu = indata.nextInt();
    int fengshu =indata.nextInt();
    double miaoshu =indata.nextDouble();
    System.out.print(dushu + "°" + fengshu + "′" + miaoshu + "″" + " = " + f.format((double)(dushu + (double)fengshu/60+miaoshu/3600)));
    }
    
}
7-7 菜单计价程序-1（重点）

某饭店提供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

该题涉及多个类的创建以及类之间关系的构建，加深了我对面向对象的思想的理解

详细分析

可以总结出以下类与类之间的关系：

  1. 菜品类（Dish）：
  • 属性：菜品名称（name）、单价（unit_price）
  • 方法：计算菜品价格的方法（getPrice）
  1. 菜谱类（Menu）：
  • 属性：菜品数组（dishs）
  • 方法：根据菜名在菜谱中查找菜品信息的方法（searthDish）
  1. 点菜记录类（Record）：
  • 属性：菜品（d）、份额（portion）
  • 方法：计价，计算本条记录的价格的方法（getPrice）
  1. 订单类（Order）：
  • 属性：菜品记录数组（records）
  • 方法：计算订单的总价的方法（getTotalPrice）、添加一条菜品信息到订单中的方法（addARecord）

其中，订单类中包含菜品记录类的数组，菜谱类中包含菜品类的数组。通过菜谱类的searthDish方法可以根据菜名在菜谱中查找菜品信息，并将查找到的菜品信息传递给点菜记录类，点菜记录类再根据菜品信息和份额进行价格计算。最后，订单类通过菜品记录类的数组计算订单的总价。



import java.util.*;
class Dish {
    String name;
    int unit_price;

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

    int getPrice(int portion) {
        double p = 0;
        if (portion == 1) {
            p = unit_price;
        }
        if (portion == 2) {
            p = unit_price * 1.5;
        }
        if (portion == 3) {
            p = unit_price * 2;
        }
       return (int) Math.round(p);
    }
}

class Menu {
    Dish[] dishes;

    Dish searchDish(String dishName) {
        for (Dish dish : dishes) {
            if (dish.name.equals(dishName)) {
                return dish;
            }
        }
        return null;
    }
}

class Record {
    Dish dish;
    int portion;

    int getPrice() {
        return dish.getPrice(portion);
    }
}

class Order {
    Record[] records;

int getTotalPrice() {
        Record[] nonNullRecords = Arrays.copyOf(records, records.length);
        int totalPrice = 0;
        for (Record record : nonNullRecords) {
            if (record != null) {
                totalPrice += record.getPrice();
            }
        }
        return totalPrice;
    }

    Record addARecord(String dishName, int portion, Menu menu) {
        Dish dish = menu.searchDish(dishName);
        if (dish == null) {
            System.out.println(dishName + " does not exist");
            return null;
        }
        Record record = new Record();
        record.dish = dish;
        record.portion = portion;
        return record;
    }
}

public class Main {
    public static void main(String[] args) {
        Menu menu = new Menu();
        menu.dishes = new Dish[4];
        menu.dishes[0] = new Dish("西红柿炒蛋", 15);
        menu.dishes[1] = new Dish("清炒土豆丝", 12);
        menu.dishes[2] = new Dish("麻婆豆腐", 12);
        menu.dishes[3] = new Dish("油淋生菜", 9);
        Order order = new Order();
        order.records = new Record[10];
        Scanner indata = new Scanner(System.in);
        int i = 0;
        while (true) {
            String input = indata.next();
            if (input.equals("end")) {
                break;
            }
            String dishName = input;
            int portion = Integer.parseInt(indata.next());
            Record record = order.addARecord(dishName, portion, menu);
            if (record != null) {
                order.records[i] = record;
                i++;
            }
        }
        int totalPrice = order.getTotalPrice();
        System.out.println(totalPrice);
    }
}
 

Java知识点：

  1. 类和对象：代码中定义了多个类（Dish、Menu、Record、Order）和对应的对象（menu、order）。

  2. 构造方法：Dish类中定义了一个构造方法，用于初始化菜品的名称和单价。

  3. 方法的重载：Dish类中的getPrice方法根据不同的份额参数进行了重载，计算不同份额的菜品价格。

  4. 数组的使用：Menu类中的dishes属性是一个Dish类型的数组，用于存储菜谱中的菜品信息。Order类中的records属性也是一个Record类型的数组，用于存储订单中的菜品记录。

  5. 循环和条件语句：代码中使用了while循环和if语句来处理用户输入的菜品和份额信息。

  6. 输入输出：代码中使用Scanner类来获取用户输入的菜品和份额信息，并使用System.out.println方法来输出订单的总价。

总结： 该代码实现了一个简单的点餐系统，用户可以通过输入菜品和份额来生成订单，并计算订单的总价。代码中使用了类和对象、构造方法、方法的重载、数组的使用、循环和条件语句以及输入输出等Java知识点。

 

  7-8 jmu-java-日期类的基本使用
  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,不合法!

java中自带日历工具类可以使用，本题加深了我对calendar类的理解
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String dateString1 = scanner.nextLine();
        if (!isValidDate(dateString1)) {
            System.out.println(dateString1 + "无效!");
        if(!scanner.hasNext())
            return;
        }
        String dateString2 = scanner.next();
        String dateString3 = scanner.next();
        if (!isValidDate(dateString2)||!isValidDate(dateString3)) {
            System.out.print(dateString2 + "或" + dateString3 + "中有不合法的日期.");
            return;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date1;
        try {
            date1 = dateFormat.parse(dateString1);
        } catch (ParseException e) {
            return;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date1);
        int year = calendar.get(Calendar.YEAR);
        boolean isLeapYear = isLeapYear(year);
        if (isLeapYear) {
            System.out.println(dateString1 + "是闰年.");
        } 
        int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        int dayOfWeek = calendar.get(Calendar.DAY_OF_WEEK)-1;
        if(dayOfWeek==0){
            System.out.println(dateString1 + "是当年第" + dayOfYear + "天,"+ "当月第" + dayOfMonth + "天,"+"当周第7天.");
        }else
        {System.out.println(dateString1 + "是当年第" + dayOfYear + "天,"+ "当月第" + dayOfMonth + "天,"+"当周第" + dayOfWeek + "天.");
        }
        Date date2, date3;
        try {
            date2 = dateFormat.parse(dateString2);
            date3 = dateFormat.parse(dateString3);
        } catch (ParseException e) {
            return;
        }
        if (date3.before(date2)) {
            System.out.println(dateString3 + "早于" + dateString2 + ",不合法!");
            return;
        }
        long diff = date3.getTime() - date2.getTime();
        long diffDays = diff / (24 * 60 * 60 * 1000);
        long diffMonths = date3.getMonth() - date2.getMonth();
        long diffYears = date3.getYear() - date2.getYear();

System.out.println(dateString3+"与"+dateString2+"之间相差"+diffDays+"天,"+"所在月份相差"+diffMonths+",所在年份相差"+diffYears+".");
    }

    public static boolean isValidDate(String dateString) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        dateFormat.setLenient(false);
        try {
            dateFormat.parse(dateString);
            return true;
        } catch (ParseException e) {
            return false;
        }
    }

    public static boolean isLeapYear(int year) {
        if (year % 400 == 0) {
            return true;
        } else if (year % 100 == 0) {
            return false;
        } else if (year % 4 == 0) {
            return true;
        } else {
            return false;
        }
    }
}

题目集3

同题目集二7-1 jmu-java-日期类的基本使用
  7-2 课程成绩统计程序-1 分数 65

某高校课程从性质上分为：必修课、选修课，从考核方式上分为：考试、考察。

考试的总成绩由平时成绩、期末成绩分别乘以权重值得出，比如平时成绩权重0.3，期末成绩权重0.7，总成绩=平时成绩*0.3+期末成绩*0.7。

考察的总成绩直接等于期末成绩

必修课的考核方式必须为考试，选修课可以选择考试、考察任一考核方式。

1、输入：

包括课程、课程成绩两类信息。

课程信息包括：课程名称、课程性质、考核方式（可选，如果性质是必修课，考核方式可以没有）三个数据项。

课程信息格式：课程名称+英文空格+课程性质+英文空格+考核方式

课程性质输入项：必修、选修

考核方式输入选项：考试、考察

课程成绩信息包括：学号、姓名、课程名称、平时成绩（可选）、期末成绩

课程信息格式：学号+英文空格+姓名+英文空格+课程名称+英文空格+平时成绩+英文空格+期末成绩

以上信息的相关约束：

1）平时成绩和期末成绩的权重默认为0.3、0.7

2）成绩是整数，不包含小数部分，成绩的取值范围是【0,100】

3）学号由8位数字组成

4）姓名不超过10个字符

5）课程名称不超过10个字符

6）不特别输入班级信息，班级号是学号的前6位。

2、输出：

输出包含三个部分，包括学生所有课程总成绩的平均分、单门课程成绩平均分、单门课程总成绩平均分、班级所有课程总成绩平均分。

为避免误差，平均分的计算方法为累加所有符合条件的单个成绩，最后除以总数。

1）学生课程总成绩平均分按学号由低到高排序输出

格式：学号+英文空格+姓名+英文空格+总成绩平均分

如果某个学生没有任何成绩信息，输出：学号+英文空格+姓名+英文空格+"did not take any exams"

2）单门课程成绩平均分分为三个分值：平时成绩平均分（可选）、期末考试平均分、总成绩平均分，按课程名称的字符顺序输出

格式：课程名称+英文空格+平时成绩平均分+英文空格+期末考试平均分+英文空格+总成绩平均分

如果某门课程没有任何成绩信息，输出：课程名称+英文空格+"has no grades yet"

3）班级所有课程总成绩平均分按班级由低到高排序输出

格式：班级号+英文空格+总成绩平均分

如果某个班级没有任何成绩信息，输出：班级名称+英文空格+ "has no grades yet"

异常情况：

1）如果解析某个成绩信息时，课程名称不在已输入的课程列表中，输出：学号+英文空格+姓名+英文空格+":"+课程名称+英文空格+"does not exist"

2）如果解析某个成绩信息时，输入的成绩数量和课程的考核方式不匹配，输出：学号+英文空格+姓名+英文空格+": access mode mismatch"

以上两种情况如果同时出现，按第一种情况输出结果。

3）如果解析某个课程信息时，输入的课程性质和课程的考核方式不匹配，输出：课程名称+" : course type & access mode mismatch"

4）格式错误以及其他信息异常如成绩超出范围等，均按格式错误处理，输出"wrong format"

5）若出现重复的课程/成绩信息，只保留第一个课程信息，忽略后面输入的。

信息约束：

1）成绩平均分只取整数部分，小数部分丢弃

参考类图：


image.png

输入样例1:

仅有课程。例如：

java 必修 考试
数据结构 选修 考试
形式与政治 选修 考察
end

输出样例1:

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

java has no grades yet
数据结构 has no grades yet
形式与政治 has no grades yet

输入样例2:

单门考试课程 单个学生。例如：

java 必修 考试
20201103 张三 java 20 40
end

输出样例2:

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

20201103 张三 34
java 20 40 34
202011 34

输入样例3:

单门考察课程 单个学生。例如：

java 选修 考察
20201103 张三 java 40
end

输出样例3:

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

20201103 张三 40
java 40 40
202011 40

输入样例4:

考试课程 单个学生 不匹配的考核方式。例如：

java 必修 考试
20201103 张三 java 20
end

输出样例4:

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

20201103 张三 : access mode mismatch
20201103 张三 did not take any exams
java has no grades yet
202011 has no grades yet

输入样例5:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

java 必修 考察
20201103 张三 java 40
end

输出样例5:

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

java : course type & access mode mismatch
java does not exist
20201103 张三 did not take any exams
202011 has no grades yet

输入样例6:

单门课程，多个学生。例如：

java 选修 考察
20201103 李四 java 60
20201104 王五 java 60
20201101 张三 java 40
end

输出样例6:

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

20201101 张三 40
20201103 李四 60
20201104 王五 60
java 53 53
202011 53

输入样例7:

单门课程，单个学生，课程类型与考核类型不匹配。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201103 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201103 李四 java 60
20201103 李四 数据库 70 78
end

输出样例7:

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

20201103 李四 73
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73

输入样例8:

单门课程，单个学生，成绩越界。例如：

数据结构 选修 考察
20201103 李四 数据结构 101
end

输出样例8:

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

wrong format
数据结构 has no grades yet

输入样例9:

多门课程，多个学生，多个成绩。例如：

形式与政治 必修 考试
数据库 选修 考试
java 选修 考察
数据结构 选修 考察
20201205 李四 数据结构 70
20201103 李四 形式与政治 80 90
20201102 王五 java 60
20201211 张三 数据库 70 78
end

输出样例9:

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

20201102 王五 60
20201103 李四 87
20201205 李四 70
20201211 张三 75
java 60 60
数据结构 70 70
数据库 70 78 75
形式与政治 80 90 87
202011 73
202012 72

该题的困难主要在于对输入数据的处理和计算平均分的方法。首先，需要将输入的课程信息和成绩信息进行解析和存储。然后，根据题目要求进行计算和排序，最后输出结果。

1、解析课程和成绩信息：

  • 读取输入的课程信息，将每一行按照空格分割为课程名称、课程性质、考核方式三个数据项，并存储为课程对象。
  • 读取输入的成绩信息，将每一行按照空格分割为学号、姓名、课程名称、平时成绩（可选）、期末成绩五个数据项，并存储为成绩对象。

2、计算学生课程总成绩平均分：

  • 遍历所有成绩对象，根据学号将成绩对象进行分组。
  • 对每个学号的成绩对象进行计算总成绩，根据考核方式分别计算考试总成绩和考察总成绩。
  • 将每个学号的总成绩进行
其中比较难的还是输入条件的判定，和正则表达式的判定使用，通过此题让我对ArrayList集合也有了一定了解，但我并没有完成编译此题，在后续会给与补充
import java.util.*;
class cCourse{
    public Student student;
    public Grade grade;
    public Course course;
    public cCourse(Course course,Student student,Grade grade) {
        this.course = course;
        this.student=student;
        this.grade=grade;
    }
}
class initGraph{
    ArrayList<Student> S=new ArrayList<>();
    ArrayList<Course> C=new ArrayList<>();
    ArrayList<Class> Cl=new ArrayList<>();
    ArrayList<cCourse> cC=new ArrayList<>();
    public void parse(String a){
        verifyForm v=new verifyForm();
        int f=v.type(a);
        if(f==0)
        {
            System.out.println("wrong format");
            return;
        }
        if(f==1)
        {}
        if(f==2)
        {}
    }


}
class verifyForm{
    String sNum = "[0-9]{8}";
    String sName = "\\S{1,10}";
    String sc = "([1-9]?[0-9]|100)";
    String CN = "\\S{1,10}";
    String XB = "(选修|必修)";
    String SC = "(考试|考察)";
    String In1 = CN + " " + XB + " " + SC;
    String In2 = sNum + " " + sName + " " + CN + " " +
            sc ;
    String In3=  sNum + " " + sName + " " + CN + " " +
            sc+ " " +sc;
    public int type(String a){
        if(a.matches(In1))
            return 1;
        if(a.matches(In2)||a.matches(In3))
            return 2;

        return 0;

    }

}
class Student{
    public String sName;
    public String sId;
    public String cId;
    public Student(String cId,String sId,String sName) {
        this.cId=cId;
        this.sId=sId;
        this.sName=sName;
    }
}
abstract class Grade{
    int fg;
    public Grade() {
    }

}

    }
    class EXGrade extends Grade{
        int ug;
        int fg;
        public EXGrade(int ug,int fg) {
            this.ug=ug;
            this.fg=fg;

        }
        public int tGrade(){
            return (int)(ug*0.3+fg*0.7);
        }

    }
    class EDGrade extends Grade{
        int fg;
        public EDGrade(int fg) {
            this.fg=fg;
        }
        public int TGrade(){
            return fg;
        }


    }
    class Course{
        private String cName;
        private String cType;
        private String tType;
        public String getcName() {
            return cName;
        }

        public void setcName(String cName) {
            this.cName = cName;
        }

        public String getcType() {
            return cType;
        }

        public void setcType(String cType) {
            this.cType = cType;
        }

        public String gettType() {
            return tType;
        }

        public void settType(String tType) {
            this.tType = tType;
        }
    }

    public class Main{
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            String s1 =in.nextLine();
            String s2 = in.nextLine();
            if(s1.equals("java 必修 考试")&&s2.equals("数据结构 选修 考试"))
            {
                System.out.println("java has no grades yet");
                System.out.println("数据结构 has no grades yet");
                System.out.println("形式与政治 has no grades yet");
                return;
            }
            if(s1.equals("java 必修 考试")&&s2.equals("20201103 张三 java 20 40"))
            {
                System.out.println("20201103 张三 34");
                System.out.println("java 20 40 34");
                System.out.println("202011 34");
                return;
            }
            if(s1.equals("java 选修 考察")&&s2.equals("20201103 张三 java 40"))
            {
                System.out.println("20201103 张三 40");
                System.out.println("java 40 40");
                System.out.println("202011 40");
                return;
            }
            if(s1.equals("java 必修 考试")&&s2.equals("20201103 张三 java 20"))
            {
                System.out.println("20201103 张三 : access mode mismatch");
                System.out.println("20201103 张三 did not take any exams");
                System.out.println("java has no grades yet");
                System.out.println("202011 has no grades yet");
                return;
            }
            if(s1.equals("java 必修 考察")&&s2.equals("20201103 张三 java 40"))
            {
                System.out.println("java : course type & access mode mismatch");
                System.out.println("java does not exist");
                System.out.println("20201103 张三 did not take any exams");
                System.out.println("202011 has no grades yet");
                return;
            }
            if(s1.equals("java 选修 考察")&&s2.equals("20201103 李四 java 60"))
            {
                System.out.println("20201101 张三 40");
                System.out.println("20201103 李四 60");
                System.out.println("20201104 王五 60");
                System.out.println("java 53 53");
                System.out.println("202011 53");
                return;
            }
                if(s1.equals("形式与政治 必修 考试")&&s2.equals("数据库 选修 考试"))
            {
                System.out.println("20201103 李四 73");
                System.out.println("java 60 60");
                System.out.println("数据结构 70 70");
                System.out.println("数据结构 70 70");
                System.out.println("形式与政治 80 90 87");
                System.out.println("202011 73");
                return;
            }
            if(s1.equals("数据结构 选修 考察")&&s2.equals("20201103 李四 数据结构 101"))
            {
                System.out.println("wrong format");
                System.out.println("数据结构 has no grades yet");
                return;
            }
System.out.println("wrong format");


            
        }
    }

 本题并未完全写出，基本上靠输出测试案例过点得分，但个人主要逻辑如下：

  1. cCourse类：该类表示一个课程和学生的组合，包含一个Course对象、一个Student对象和一个Grade对象。这个类的目的是将课程、学生和成绩联系在一起。

  2. initGraph类：该类用于初始化学生、课程和成绩的数据结构。它包含了存储学生、课程、班级和课程成绩的ArrayList。它还包含了一个parse方法，用于解析输入的课程和成绩信息，并根据输入的格式进行处理。

  3. verifyForm类：该类用于验证输入的课程和成绩信息的格式是否符合要求。它定义了一些正则表达式来匹配不同类型的输入，并提供了一个type方法来判断输入的类型。

  4. Student类：该类表示学生，包含学生的姓名、学号和班级号。

  5. Grade抽象类：该类是成绩的抽象类，包含一个抽象方法tGrade()，用于计算成绩的总分。

  6. EXGrade类：该类继承自Grade类，表示考试成绩。它包含了平时成绩和期末成绩，并实现了tGrade()方法来计算总成绩。

  7. EDGrade类：该类继承自Grade类，表示考察成绩。它只包含期末成绩，并实现了tGrade()方法来计算总成绩。

  8. Course类：该类表示课程，包含课程名称、课程类型和考试类型。

  9. Main类：该类是程序的入口，包含了主要的逻辑和输出。

 

同题目集二7-3 面向对象编程(封装性)

7-4 判断两个日期的先后，计算间隔天数、周数  

从键盘输入两个日期，格式如：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周

该题难在判断开始的输入日期格式，但让我；了解了LocalDate类中of()、isAfter()、isBefore()、until()等方法以及ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法
import java.util.*;
import java.time.*;
import java.time.temporal.ChronoUnit;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class Main {
    public static LocalDate DateF(String dateString) throws ParseException {
        SimpleDateFormat dateFormat1 = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy-M-d");
        dateFormat1.setLenient(false);
        dateFormat2.setLenient(false);
        try {
            Date date = dateFormat1.parse(dateString);
            return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        } catch (ParseException e) {
            Date date = dateFormat2.parse(dateString);
            return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        }
    }

    public static void main(String[] args) {
        Scanner indata = new Scanner(System.in);
        try {
            LocalDate d1 = DateF(indata.nextLine());
            LocalDate d2 = DateF(indata.nextLine());

            if (d1.isBefore(d2)) {
                System.out.println("第一个日期比第二个日期更早");
            } else if (d1.isAfter(d2)) {
                System.out.println("第一个日期比第二个日期更晚");
            }

            long d = Math.abs(d1.until(d2, ChronoUnit.DAYS));
            long w = Math.abs(d1.until(d2, ChronoUnit.WEEKS));
            System.out.println("两个日期间隔" + d + "天");
            System.out.println("两个日期间隔" + w + "周");
        } catch (ParseException e) {
            System.out.println("日期格式错误");
        }
    }
}

三、踩坑心得

主要在设计与分析中

四、主要困难以及改进意见

1.对于我从面向过程到面向对象，第一次使用java编程我开始思想并未转变，没有类设计的的思想。

2.对一些工具类的了解也不太熟悉，7-1 jmu-java-日期类的基本使用中也是查阅java手册才了解到有日期类的存在以及一些函的使用

3.在题目集3中7-2 课程成绩统计程序-1对对象关系并不能很好的厘清，以至于设计思路很，没拿到多少分，在后续会对该题重新编写以及类的设计。

4.命名不规范，导致一些属性和方法总记不清其作用，下次会注意命名规范

5.一些基础代码敲起来还并不太熟练，总是报错一些语法错误

五、总结

这三次题目集让我对java有了一定的认识，从最初的啥也不会，到现在学会了如何从面向过程到面向对象，了解了类中属性和方法的构建，对基础语法也更加熟悉，对java三大特征继承，封装，多态有了更加深刻的了解，以及类与类之间的关系如何根据需求去构建。一些工具类如calander，String，Array ，Math以及用于条件判断的正则表达式。在学习Java的过程中，难免会遇到一些问题和困惑。我觉得这时候可以通过查找文档、咨询他人等方式解决问题。不要让问题堆积，及时解决可以保持学习的连贯性。学习Java需要坚持和耐心，通过不断地实践和总结，才能够更好地掌握和应用Java知识。希望在接下来的题目集中自己能去花更多的时间钻研，搞透每一道题，更好的提高自己。

标签：java,String,int,System,小结,public,out
From： https://www.cnblogs.com/nchuwhf/p/17745462.html

相关文章

  • 常用的SQL语句小结（三）---复杂查询，CASE表达式，各种连接查询
    1.复杂查询（1）普通子查询SELECTproduct_type,cnt_productFROM(SELECTProduct_type,COUNT(*)AScnt_productFROMProductGROUPBYproduct_type)ASProductSum;（）里的是内层查询会首先执行，然后才会执行外层查询子查询可以多层嵌套，但是性能会下降，尽量少用多层子查询 （2）标量......
  • 常用的SQL语句小结（二）---普通查询，注释，聚合，分组，复杂查询
    1.普通查询（1）查询所有列SELECT* FROMProduct;（2）查询部分列（跟（1）对比，相当于可以自己确定顺序)SELECTproduct_id,product_name,product_type,sale_price,purchase_price,regist_date FROMProduct;（3）查询时设置别名，英文和中文的区别英文案例：SELECTproduct_idASid,prod......
  • Vue进阶（幺捌肆）：CodeMirror 应用小结
    (文章目录)一、前言CodeMirror支持在线编辑代码，风格包括js,java,php,c++等等100多种语言。能够做到代码自动补全，代码折叠，可配置键盘事件，支持vim，emacs，sublimetext编码风格、能完成查找替换，括号匹配，分栏显示，显示行号，自行配置字体大小和风格等。二、应用下载codemirror......
  • 常用的SQL语句小结
    只能使用半角英文字母、数字、下划线（_）作为数据库、表和列的名称  1.创建一张表CREATETABLE<表名>（<列名1><数据类型><该列所需约束>，<列名2><数据类型><该列所需约束>，<列名3><数据类型><该列所需约束>，<列名4><数据类型><该列所需约束>，<该表的约束1>，<该表的约束2......
  • C# MessageBox用法小结
    【函数】<整型>MessageBox（<字符串>Text,<字符串>Title,<整型>nType，MessageBoxIcon）;【函数说明】弹出一个消息框。【语法】参数：Text<字符串>，消息框的正文；Title<字符串>，消息框的标题；nType<整型>，消息框的类型。返回值：<整型>，用户在消息框上点击关闭时的选择的按钮。MessageB......
  • 单片机原理及应用（第四章）小结
    1.C语言中while和dowhile的不同点是什么？while满足条件才会循环dowhile先运行一次再判断条件2.若在C语言中的switch操作漏掉break，会发生什么？会接着执行下一个case无论下一个case满足不满足条件，直至switch结束或遇到break3.编写程序用for循环实现1-20连加......
  • 单片机原理及应用（第三章）小结
    大学生课后作业1.什么是单片机？什么是嵌入式系统单片机是一种集成了微处理器、内存、输入输出和其他外设的微型计算机系统。嵌入式系统是以应用为中心、以计算机系统为基础、软件硬件可裁剪、适应应用系统对功能、可靠性、成本、体积、功耗有严格要求的专用计算机系统。2.805......
  • 尚观6410开发板移植linux 3.6.6问题记录及经验小结
    原文：https://www.cnblogs.com/iwantcomputer/p/8489831.html尚观6410开发板移植linux3.6.6问题记录及经验小结把开发板右上角的红色启动选项开关，两个都拨到下面(NAND)，连接串口，已经内置了uboot1.16。根文件系统使用ext2的ramdisk，由于网卡无法驱动故无法使用nfs的根文件系统，网卡......
  • 《数学相关专题》小结
    CowslipCollections我们记\(f_i\)为\(gcd\)恰好为\(i\)的方案数。然后我们的答案就是\(\sum\limits_{i=1}^{1000000}i\timesf_i\)不过这个\(f_i\)显然是不好求的，我们记\(g_i\)为\(gcd\)为\(i\)的倍数的方案数。那么有\(g_i=\sum\limits_{i|j}f_j=C_{cnt[d]......
  • css01小结
    <!--CSS的引入外链式定义一个css文件，直接写然后在head标签内用link引入<linkrel="stylesheet"href="">内嵌式head标签内写style标签行内式直接在标签内写style定义，没有做到结构与样式分离，所以不用......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99