一、前言

本学期开展了面向对象程序设计这门课程,开始了Java语言的学习。目前,我们已完成三次pta大作业,让我收获了很多,慢慢从上个学期C语言面向过程的编程思想转变为面向对象程序设计的思想。现对三次作业做概括分析:

1.第一次作业

二、设计与分析

1.第一次作业

共九道题目,难度一般,均为基础题目,主要涉及到的主要是对java语法的认识,以及顺序结构、循环结构、选择结构等知识,这些与C语言并无太大区别,所以完成起来较为顺畅,得分为100分,但有一些数据类型的差异导致结果错误的问题,通过尝试也解决了。后续分析我将分析7-8巴比伦法求平方根近似值。

2.第二次作业

共四道题目,难度相较第一次大大提升,主要涉及到对java工具包中所包含的一些方法的认识和使用,与C相比所能使用的方法更丰富(在写的时候并不知道),并且涉及到对类的编写,当时我对类的理解不够,使用类也不熟练,所以这次作业完成情况并不理想,在后续的学习中,我才逐渐明白,类可以说是C语言中结构体的升级版,其中不但包括成员属性,也包括成员方法。后续的分析我将分析7-1 菜单计价程序-1,7-2 菜单计价程序-2,7-3 jmu-java-日期类的基本使用。

3.第三次作业

共七道题目,难度相较第二次有所下降,主要涉及到类变量和类方法和面向对象编程之封装性,还有时间有关的类方法,以及字符串相关知识,属于Java的一些进阶知识,除了的一道菜单计价系列3,其余的题目,我通过自学相关内容都完成了。在后续的分析中,我将分析7-1 菜单计价程序-3,7-2 有重复的数据。

 

以及对数组的使用,java中的数组是一种对象,在声明时需要借助关键词new

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.*;
public class Main
{
    public static void main(String []args){
        Scanner input = new Scanner(System.in);
        float a=input.nextFloat();//n
        float b=input.nextFloat();//lastGuess
        if(a<0||b<=0){
            System.out.println("Wrong Format");
            return;
        }
        float c=(b+a/b)/2; //nextGuess
        while(Math.abs(c-b)>=0.00001)
        {
            b=c;
            c=(b+a/b)/2;
        }
        System.out.println((float)b);
    }
}

这道题本身难度不大,主要问题在于不同数据类型计算带来的误差,根据我所搜索的知识可知:单精度与双精度精确范围不同,从运行结果来说,单精度浮点数小数部分只有前6位是准确的,而双精度浮点数小数部分9位都是准确的。最后,测试了很多遍,发现用float类型可以通过测试。

2.

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
import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner n = new Scanner(System.in);
        String dish; 
        int portion; 
        double price=0; 
        double tprice=0;
        while(true)
        {
            dish = n.next();
            if (dish.equals("end"))
                break;
            portion = n.nextInt();
            switch (dish) 
                {
                case "西红柿炒蛋":
                    {
                        switch(portion)
                        { case 1:
                        price=15;break;
                        case 2:
                        price =15*1.5;break;
                        case 3:
                        price=15*2;
                        break;}
                    }
                    break;
                case "清炒土豆丝":
                    {
                        switch(portion)
                        {  case 1:
                        price=12;break;
                        case 2:
                        price =12*1.5;break;
                        case 3:
                        price=12*2;break;}
                    }
                    break;
                case "麻婆豆腐":
                    {
                        switch(portion)
                        { case 1:
                        price=12;break;
                        case 2:
                        price =12*1.5;break;
                        case 3:
                        price=12*2;break;}
                    }
                    break;
                case "油淋生菜":
                    {
                        switch(portion)
                        {   case 1:
                        price=9;break;
                        case 2:
                        price =9*1.5;break;
                        case 3:
                        price=9*2;break;
                    }}
                    break;
                default:
                    System.out.println(dish+' '+"does not exist");
                    continue;}
            tprice+=price;
         }
        System.out.println(Math.round(tprice));
    }
}

这是菜单计价系列的第一题,也是我该系列唯一满分的一题,分析整个菜单系列,我觉得我存在的问题没有转变对面向对象的编程思想,回顾这道题,我用的还是上个学期程序设计基础所学的面向过程的编程思想,并且我不会使用类及类方法;还有一个比较严重的问题,就是第一次写这个作业的受挫导致我产生了畏难心理,后续有些不太相碰这道题,其实这种想法是不对的,我现在也在慢慢克服这个问题,尝试写菜单计价系列的第二题。

除此之外,我在写这道题目的时候,也发现在如果结尾的输出函数”System.out.println(Math.round(tprice));“,不使用Math.round()的话,会造成部分结果错误。Math.round其实就是四舍五入,以下为我搜索到的相关资料:如果内容不是个数字,返回0;\n\n如果内容负无限大或者小于等于long的最小值,返回Long.MIN_VALUE;\n\n如果内容正无限大或者大于等于long的最大值,返回Long.MAX_VALUE;

3.

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

import java.util.Scanner;
public class Main
{
    public static void main(String[] args)
    {
        Scanner input=new Scanner(System.in);
        String []menu =new String[500];
        int []price=new int[500];
        String menuName;
        int inputPrice;
        int i=0;
        String wholeJudge;
        while(true)
        {
            int reption=1;
            menuName=input.next();
            if(menuName.equals("1"))
            {
                wholeJudge="1";
                break;
            }
            if(menuName.equals("end"))
            {
                wholeJudge="0";
                break;
            }
            inputPrice=input.nextInt();
            for(int k=0;k<i;k++)
                if(menuName.equals(menu[k]))
                {
                    price[k]=inputPrice;reption=0;
                    break;
                }
            if(reption==1)
            {
                menu[i]=menuName;
                price[i]=inputPrice;
                i++;
            }
        }
        int everyPrice=0;
        int totalPrice = 0;
        int count=0;
        int []recording=new int[100];
        int re=0;
        int judge3=1,judge2=0;
        String endJudge="";
        if(wholeJudge.equals("1"))
            while(!wholeJudge.equals("end"))
            {
                everyPrice=0;
                int flag=0;
                String order=input.next();
                if(order.equals("delete"))
                {
                    if(judge2==1&&judge3==0)
                        wholeJudge = endJudge;
                    int p=Integer.parseInt(wholeJudge);
 
                    if(p<1||p>count||recording[p-1]==0)
                        System.out.println("delete error;");
                    if(p>=1&&p<=count&&recording[p-1]!=0)
                    {
                        totalPrice -= recording[p-1];
                        recording[p-1]=0;
                    }
                    endJudge = input.next();
                    judge3 = 0;
                    if(endJudge.equals("end"))
                        break;
                    else
                    {
                        judge2=1;
                        wholeJudge=endJudge;
                        continue;
                    }
                }
                else judge3=1;
                int size1=input.nextInt();
                int b=input.nextInt();
                for(int j=0;j<i;j++)
                {
                    if(order.equals(menu[j]))
                    {
                        flag=1;
                        if(size1==1)everyPrice+=price[j];
                        if(size1==2)
                        {
                            if(price[j]%2==1)
                                everyPrice+=price[j]*1.5+1;
                            else
                                everyPrice+=price[j]*1.5;
                        }
                        if(size1==3)
                            everyPrice+=2*price[j];
                    }
                }
 
                if(flag==0)
                {
                    recording[re++]=0;
                    System.out.println(order+" does not exist");
                    count++;
                }
 
                if(flag==1)
                {
                    everyPrice*=b;
                    totalPrice+=everyPrice;
                    recording[re++]=everyPrice;
                    System.out.println(wholeJudge+" "+order+" "+everyPrice);
                    count++;
                }
                wholeJudge=input.next();
            }
 
        if(!wholeJudge.equals("0"))
            System.out.println(totalPrice);
        else System.out.println("0");
    }
}

以上为我仿写的代码,其实后来发现难度并没有想象的那么大,主要还是对类的创建及使用不够熟练

4.

7-3 jmu-java-日期类的基本使用
分数 15

全屏浏览题目

切换布局
作者 郑如滨
单位 集美大学
给定一个日期,判定是否为合法日期。如果合法,判断该年是否闰年,该日期是当年第几天、当月第几天、当周第几天、。
给定起始日期与结束日期,判定日期是否合法且结束日期是否早于起始日期。如果均合法,输出结束日期与起始日期之间的相差的天数、月数、念书。
输入格式:
第一行输入一个日期字符串,格式为"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

这道题我开始也不会写来着,光是检验时间合法性和判断日期所在年月日就写了一百多行,就放弃了。但是在下一周学完Java日期时间类以后,发现这道题还是比较好写的,还是应该加强自学能力

4.

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
内存限制

 

 

第三次作业的时间比较紧,题目量也不小,所以我当时放弃写这道题了,我主要把菜单计价系列2重新写了,但其实从我写的菜单计价2的圈复杂度和软件质量的表可以看出我这个题的复杂度是非常高的,效率低,维护成本高ifelse

语句使用过多,代码执行效率过低。如果要是想要改进的话,应该把if else语句去掉,换成数组或switch,便可以大大提升我们的编程效率。所以怎么去创建适合的类和类方法还是我现在比较薄弱的点

5.

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.*;
 public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int i;
        int n=input.nextInt();
        input.nextLine();
        String a = input.nextLine();
        String[] b = a.split(" ");
        Set<Integer> set = new HashSet<Integer>();
        for(i=0; i<n; i++) 
        {
            set.add(Integer.parseInt(b[i]));
        }
        if (set.size() == n) {
            System.out.println("NO");
        }else {
            System.out.println("YES");
        }
    }
}

本题使用LinkedHashSet,主要是因为本题数据范围大,数据复杂度高,使用选择排序法和冒泡排序法都会无法通过测试点,LinkHashSet是Set实现类HashSet的一个子类,使用链表来维护元素的次序。本题需要保证原有的顺序实现去重,所以需使用LinkedHashSet。

三、踩坑心得

1.第一次作业中的精度问题,不同数据类型计算带来的误差,根据我所搜索的知识可知:单精度与双精度精确范围不同,所以开始我有好几道题死活通不过测试点,一直在显示结果错误(如上一部分所分析的7-8),今后在写代码的时候也应注意这个问题

2.第三次作业中的7-2 有重复的数据这道题我开始一直是想把数据存入数组,然后对比数组元素是否重复,但是这样是通过不了测试点的,时间复杂度太高。然后,后面学习才知道可以将数据存入Hashset集合,再通过set.size()ba判断集合中对象个数是否减少(Set集合是由一串无序的,不能重复得相同类型元素构成的集合)

3.第三次作业中的7-4 单词统计与排序要求从键盘录入一段英文文本(句子之间的标点符号只包括“,”或“.”,单词之间、单词与标点之间都以" "分割),我后来学习到中的Java的string类型提供了一个Split方法,可以用来分割字符串。该方法接受一个字符数组作为参数,表示分割字符串的分隔符,返回一个字符串数组,其中的每个元素都是原始字符串中被分隔符分割的部分。

4.第三次作业中的7-7 判断两个日期的先后,计算间隔天数、周数,通过这道题,我了解了通过查询Scanner类中nextLine()等方法、String类中split()等方法、Integer类中parseInt()等方法的用法,了解LocalDate类中of()、isAfter()、isBefore()、until()等方法的使用规则,了解ChronoUnit类中DAYS、WEEKS、MONTHS等单位的用法,所以Java相较于我们上个学期学习的C语言有很多类工具与方法,我们还是要在课余时间多多自学。

四.主要困难和改进建议

1.代码的复杂度高,编程的质量不高,我认为要减少选择语句if else,改用switch或者数组,这样可以提高程序运行效率。

2.对于类的理解不够,一个类里面的属性与方法,应该有单一原则,单一职责原则核心思想是一个类,最好就做一件事。就如老师上课所说的类与类之间的关联性越小越好,而我所写的一些程序,互相关联的太多,导致不太好改。测试对于编码质量是非常重要的,虽然我们pta不对这个做要求,我们也应该对自己所编写的代码持有高度的严谨性,尽可能提高代码质量。

 

五.总结

博客作业对我们来说是一种很重要的总结并反思的机会。以下是我对此次博客的内容进行总结:

从我自身的角度,三次作业我学习了解了类的构造方法、方法的调用,以及参数传递、对象的构造与使用;并且熟悉了循环结构、控制结构;掌握了数据的输入与输出;同时明白了程序编写结构清晰、逻辑正确、功能完善的java代码的重要性

从课堂的角度,线上线下相结合的模式。线上需通过学习通自学相关Java内容,老师根据题目的完成情况讲产生的学各种知识, 这种课堂模式非常具有创新性,大大增强了课堂效率。但其实从另外一方面也很考验我的自觉性,我经常会因为没有及时看网课而导致课跟不上,这也是我需要改的点。除此之外,由于题目难度较大(对我来说),也希望老师在课堂上面,除了基本知识的讲解,可以讲解一下作业。

 

 posted on 2023-03-31 19:00  波浪22206102  阅读(203)  评论(0编辑  收藏  举报