其他分享
首页 > 其他分享> > 题集1~3总结

题集1~3总结

作者：互联网

前言：对于题集1~3的题目来说，题集1较为简单，只有一些比较简单的计算，题量也不是很大，但这也是我第一次接触到Java，让我初步了解到了Java的语法。而题集2难度有了明显的提升，主要是练习我们对遇到的问题的多方位的思考，有条理的分析问题，考虑到每一种不同的情况，再根据不同的情况指定不同的解决方法。而题集3不出意料，是最难的一次，主要是考察对类的理解和运用，更是体现出Java是面对对象的语言的特点。

（1）设计与分析：

题集1：












 


 


 题目较为常规，并没有十分难得问题，主要是一些输入输出、if-else语句、循环语句排序和一些简单的计算，因为在上个学期已经学习过C语言，这些问题比较容易解决，除了输出输入有很大变化，其他的和C语言基本类似。只是对Java中的很多语句不太清楚，懵懵懂懂的。


题目7-8：



7-8 判断三角形类型 (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


 代码如下：



 1 import java.util.Scanner;
 2 public class Main {
 3 
 4 　　public static void main(String[] atgs) {
 5 　　　　double a=0,b=0,c=0;
 6 　　　　Scanner in = new Scanner(System.in);
 7 　　　　a=in.nextDouble();
 8 　　　　b=in.nextDouble();
 9 　　　　c=in.nextDouble();
10 　　　　if(a>=1&&a<=200&&b>=1&&b<=200&&c>=1&&c<=200)
11 　　　　{
12 　　　　　　if(a+b>c&&a+c>b&&b+c>a)
13 　　　　　　{
14 　　　　　　　　if(a==b||a==c||b==c)
15 　　　　　　　　{
16 　　　　　　　　　　if((a*a+b*b)-c*c<0.1||(a*a+c*c-b*b)<0.1||(b*b+c*c-a*a)<0.1)
17 　　　　　　　　　　　　System.out.println("Isosceles right-angled triangle");
18 　　　　　　　　　　else if(a==b&&b==c)
19 　　　　　　　　　　　　System.out.println("Equilateral triangle");
20 　　　　　　　　　　else
21 　　　　　　　　　　　　System.out.println("Isosceles triangle");
22 　　　　　　　　}
23 　　　　　　　　else if((a*a+b*b)-c*c<0.000001||(a*a+c*c-b*b<0.1)||(b*b+c*c-a*a<0.1))
24 　　　　　　　　　　System.out.println("Right-angled triangle");
25 　　　　　　　　else
26 　　　　　　　　　　System.out.println("General triangle");
27 　　　　　　}
28 　　　　　　else
29 　　　　　　　　System.out.println("Not a triangle");
30 　　　　}
31 　　　　else
32 　　　　　　System.out.println("Wrong Format");
33 　　}
34 }



 




 分析：主要是运用if-else语句的嵌套，对输入的数据进行多次判断，以此来判断输入的数据是否能构成三角形以及所构成三角形的形状。而其中的难点在于多种情况的的判断，一定要考虑全面，避免漏掉某种情况。还有一个小问题，就是在判断是否是直角三角形时，用a*a+b*b=c*c是有一点问题的，要用a*a+b*b-c*c《0.1才可以，具体原因不是很清楚，因为我看不到PTA的测试数据，大概是因为在计算时因为精度有限而出现的误差。









题集2


 


题目主要还是Java的基础语法，但是需要考虑全面，尤其时计算日期的相关题目。


 


 


 



7-4 求下一天 (30 分)

 








输入年月日的值（均为整型数），输出该日期的下一天。 其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法。


要求：Main类中必须含有如下方法，签名如下：



public static void main(String[] args)；//主方法 
public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型 
public static boolean checkInputValidity(int year,int month,int day);//判断输入日期是否合法，返回布尔值
public static void nextDate(int year,int month,int day) ; //求输入日期的下一天



 

 

输入格式:


在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。


输出格式:


    

  1. 当输入数据非法及输入日期不存在时，输出“Wrong Format”；
    2. 

  2. 当输入日期合法，输出下一天，格式如下：Next date is:年-月-日
    3. 



输入样例1:


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


2020 3 10


输出样例1:


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


Next date is:2020-3-11


输入样例2:


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


2025 2 10

 

输出样例2:


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


Wrong Format

代码如下：



import java.util.Scanner;

public class Main{

    public static void main(String[] args)
    {
        
        int year=0,month=0,day=0,flag=1;
        Scanner scan = new Scanner(System.in);
        year=scan.nextInt();
        month=scan.nextInt();
        day=scan.nextInt();
                
        if(!checkInputValidity(year,month,day))
        {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        nextDate(year, month, day);    
        scan.close();
        
    }

    public static boolean checkInputValidity(int year,int month,int day)//判断输入日期是否合法，返回布尔值
    {
        int flag=1;
        if(year<1820||year>2020)
            flag=0;
        if(month>12||month<1)
            flag=0;
        if(month<=7&&month!=2)
        {
            if(month%2==0)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month>=8)
        {
            if(month%2==1)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month==2)
        {    if(isLeapYear(year))
                if(day<1||day>29)
                    flag=0;
                else;
            else
                if(day<1||day>28)
                    flag=0;
        }
        if(flag==0)
            return false;
        else
            return true;
    }
    public static void nextDate(int year,int month,int day) //求输入日期的下一天
    {
        
        int[] a1 = {31,28,31,30,31,30,31,31,30,31,30,31};//平年
        int[] a2 = {31,29,31,30,31,30,31,31,30,31,30,31};//闰年
        if(isLeapYear(year))
        {
            day+=1;
            if(day>a2[month-1])
            {
                day=1;
                month+=1;
                if(month>12)
                {
                    month=1;
                    year+=1;
                }
            }
            
        }
        else
        {
            day+=1;
            if(day>a1[month-1])
            {
                day=1;
                month+=1;
                if(month>12)
                {
                    month=1;
                    year+=1;
                }
            }
        }
        System.out.println("Next date is:"+year+"-"+month+"-"+day);
    }

    public static boolean isLeapYear(int year) 
    {
        if(year%400==0||year%4==0&&year%100!=0)
            return true;
        else
            return false;
    }//判断year是否为闰年，返回boolean类型

}



 


分析：运用了Java中的boolean类型，判断输入的日期是否合法以及是否为闰年，还有用



void nextDate(int year,int month,int day)



来计算并输出先一天的日期。难点就在于闰年的2月28日和平年的2月28日的下一天，需要单独计算，不可以和其他月份的计算放在一起。我采用将平年和润年每一月的天数写入两个数组中，这样在判断是否是闰年之后就可以直接取所对应的天数，减少了判断的次数。


采坑心得：


在判断输入日期是否合法的方法中，我自己写了好多繁琐的判断，代码如下：



 public static boolean checkInputValidity(int year,int month,int day)//判断输入日期是否合法，返回布尔值
    {
        int flag=1;
        if(year<1820||year>2020)
            flag=0;
        if(month>12||month<1)
            flag=0;
        if(month<=7&&month!=2)
        {
            if(month%2==0)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month>=8)
        {
            if(month%2==1)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month==2)
        {    if(isLeapYear(year))
                if(day<1||day>29)
                    flag=0;
                else;
            else
                if(day<1||day>28)
                    flag=0;
        }
        if(flag==0)
            return false;
        else
            return true;
    }



这些其实是可以改成先判断是否是闰年，然后和存放闰年和平年每月天数的数组里的数字进行比较即可，但我是先写完判断后才写的那两个数组，所以这里并没有改动。


改进建议：一定要写注释，不只是写一个方法的作用，还要写清楚每一个通过名字看不出含义的变量的作用，以及一些重要判断，循环的作用，既让其他人更容易阅读，也让自己在代码出现问题时更好的查找，容易更正，提高效率。


 



7-5 求前N天 (30 分)

 









输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。
注意：不允许使用Java中任何与日期有关的类或方法。


输入格式:


在一行中输入年月日的值以及n的值，可以用一个或多个空格或回车分隔。


输出格式:


    

  1. 当输入的年、月、日以及n的值非法时，输出“Wrong Format”；
    2. 

  2. 当输入数据合法时，输出“n days ago is:年-月-日”
    3. 



输入样例1:


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


2018  6 19 8 

 

输出样例1:


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


8 days ago is:2018-6-11

 

输入样例2:


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


2018  6 19 -8 

 

输出样例2:


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


-8 days ago is:2018-6-27









代码如下：



import java.util.Scanner;

public class Main{

    public static void main(String[] args)
    {
        
        int year=0,month=0,day=0,flag=1,n=0;
        Scanner scan = new Scanner(System.in);
        year=scan.nextInt();
        month=scan.nextInt();
        day=scan.nextInt();
        n=scan.nextInt();
        if(!checkInputValidity(year,month,day))
        {
            System.out.println("Wrong Format");
            System.exit(0);
        }
        if(n<-10||n>10)
        {
            System.out.println("Wrong Format");
            System.exit(0);
        }
//         输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）
        if(n<=0)
        {           
            n=-1*n;
            nextDate(year, month, day, n);
        }
        else
        {

            beforDate(year, month, day, n);
        }
            scan.close();
        
    }

    

    public static boolean checkInputValidity(int year,int month,int day)//判断输入日期是否合法，返回布尔值
    {
        int flag=1;
        if(year<1820||year>2020)
            flag=0;
        if(month>12||month<1)
            flag=0;
        if(month<=7&&month!=2)
        {
            if(month%2==0)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month>=8)
        {
            if(month%2==1)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month==2)
        {    if(isLeapYear(year))
                if(day<1||day>29)
                    flag=0;
                else;
            else
                if(day<1||day>28)
                    flag=0;
        }
        if(flag==0)
            return false;
        else
            return true;
    }
    public static void nextDate(int year,int month,int day,int n) //求输入日期的后n天
    {
        
        int[] a1 = {31,28,31,30,31,30,31,31,30,31,30,31};//平年
        int[] a2 = {31,29,31,30,31,30,31,31,30,31,30,31};//闰年
        for(int i=0;i<n;i++)
        {
            if(isLeapYear(year))
            {
                day+=1;
                if(day>a2[month-1])
                {
                    day=1;
                    month+=1;
                    if(month>12)
                    {
                        month=1;
                        year+=1;
                    }
                }
                
            }
            else
            {
                day+=1;
                if(day>a1[month-1])
                {
                    day=1;
                    month+=1;
                    if(month>12)
                    {
                        month=1;
                        year+=1;
                    }
                }
            }
        }
        n=-1*n;
        System.out.println(n+" days ago is:"+year+"-"+month+"-"+day);
    }
    private static void beforDate(int year, int month, int day, int n)//求输入日期的前n天
    {
        int[] a1 = {31,28,31,30,31,30,31,31,30,31,30,31};//平年
        int[] a2 = {31,29,31,30,31,30,31,31,30,31,30,31};//闰年
        for(int i=0;i<n;i++)
        {
            if(isLeapYear(year))
            {
                day-=1;
                if(day==0)
                {
                    if(month==1)
                        day=a2[11];
                    else
                        day=a2[month-2];
                    month-=1;
                    if(month==0)
                    {
                        month=12;
                        year-=1;
                    }
                }
                
            }
            else
            {
                day-=1;
                if(day==0)
                {
                    if(month==1)
                        day=a1[11];
                    else
                        day=a1[month-2];
                    month-=1;
                    if(month==0)
                    {
                        month=12;
                        year-=1;
                    }
                }
            }
        }
        System.out.println(n+" days ago is:"+year+"-"+month+"-"+day);
            
    }
    
    
    public static boolean isLeapYear(int year) 
    {
        if(year%400==0||year%4==0&&year%100!=0)
            return true;
        else
            return false;
    }//判断year是否为闰年，返回boolean类型

}



 


分析：这道题本来是比较麻烦的，但是可以根据上一道题来进行改，例如求后n天，我再增加一个循环，进行n次求下一天的操作即可实现求下n天，而求前n天，只需改变求下一天的年月日变化方向，以及一些细节的不同，同样在增加一个n次循环，即可实现前n天。


改进建议：同样，与上一题一样，在一些细节处没有注释，不方便检查错误以及阅读。


 


题集3



7-2 定义日期类 (28 分)

 









定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。


要求：Date类结构如下图所示：


类图.jpg


输入格式:


在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。


输出格式:



输入样例1:


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


1912 12 25

 

输出样例1:


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


Next day is:1912-12-26

 

输入样例2:


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


2001 2 30

 

输出样例2:


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


Date Format is Wrong









代码如下：



import java.util.Scanner;

public class Main{

    public static void main(String[] args)
    {
        
        
        Main m = new Main();
        Data data = m.new Data();
        int year=0,month=0,day=0;
        Scanner scan = new Scanner(System.in);
        year=scan.nextInt();
        month=scan.nextInt();
        day=scan.nextInt();
        data.year = year;
        data.month = month;
        data.day = day;
        if(!data.check(year,month,day))
        {
            System.out.println("Date Format is Wrong");
            System.exit(0);
        }
        data.getNextDate();
        
        scan.close();
        
        
    }
    
    
class Data {
    
    private int year,month,day;
    public boolean check(int year,int month,int day)//判断输入日期是否合法，返回布尔值
    {
        
        
        int flag=1;
        if(year<1900||year>2000)
            flag=0;
        if(month>12||month<1)
            flag=0;
        if(month<=7&&month!=2)
        {
            if(month%2==0)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month>=8)
        {
            if(month%2==1)
                if(day>30||day<1)
                    flag=0;
                else;
            else
                if(day>31||day<1)
                    flag=0;
        }
        if(month==2)
        {    if(isLeapYear(year))
                if(day<1||day>29)
                    flag=0;
                else;
            else
                if(day<1||day>28)
                    flag=0;
        }
        if(flag==0)
            return false;
        else
            return true;
        
        
    }
    
    
    public void getNextDate() {
        
        
        nextDate(year, month, day);
        
        
    }


    public void nextDate(int year,int month,int day) {//求输入日期的下一天
        
        
        int[] a1 = {31,28,31,30,31,30,31,31,30,31,30,31};//平年
        int[] a2 = {31,29,31,30,31,30,31,31,30,31,30,31};//闰年
        if(isLeapYear(year))
        {
            day+=1;
            if(day>a2[month-1])
            {
                day=1;
                month+=1;
                if(month>12)
                {
                    month=1;
                    year+=1;
                }
            }
            
        }
        else
        {
            day+=1;
            if(day>a1[month-1])
            {
                day=1;
                month+=1;
                if(month>12)
                {
                    month=1;
                    year+=1;
                }
            }
        }
        System.out.println("Next day is:"+year+"-"+month+"-"+day);
        
        
    }

    
    public boolean isLeapYear(int year) 
    {
        
        
        if(year%400==0||year%4==0&&year%100!=0)
            return true;
        else
            return false;
    }//判断year是否为闰年，返回boolean类型
    
    
}


}



分析：本题与题集2中题目要求实现的功能基本相同，但本题要使用Date类，并含有year，month，day三个私有属性，主要是考察对Java中类的理解和简单运用。


改进建议：将创建对象的操作放入Date类中，减少主类中的代码，让代码不会显得太乱。



7-3 一元多项式求导（类设计） (50 分)

 








编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。


输入格式:


在一行内输入一个待计算导函数的表达式，以回车符结束。


输出格式:


    

  1. 如果输入表达式不符合上述表达式基本规则，则输出“Wrong Format”。
    2. 

  2. 如果输入合法，则在一行内正常输出该表达式的导函数，注意以下几点： 结果不需要排序，也不需要化简；
    3. 




输出格式见输入输出示例。


输入样例1:


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


-2*     x^-2+  5*x^12-4*x+       12

 

输出样例1:


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


4*x^-3+60*x^11-4

 

输入样例2:


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


2*x^6-0*x^7+5

 

输出样例2:


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


Wrong Format








代码如下：


分析：利用java.util.regex中的类来进行匹配，再用Deri类中的divide（）方法分割出每一项，还要保留符号。在根据不同的格式来进行求导运算，最重要的就是要灵活运用正则表达式。


采坑心得：在分割每一项中，有两个f和k变量，用来查找每一项的开头和末尾，开始写的时候没有考虑到保留符号，所以在查找完一项后会有f=k+1，准备之后直接求出导数再输出，直接插入到原来的位置上去，然后直接可以输出，后来考虑到求导后符号发生变化，直接输出不便与改变符号，后改为f=k，分割时保留符号。


总结：


这三次题目集的练习，让我快速的了解了Java的语法，以及Java中各种类的功能的强大，也让我学习到了正则表达式的相关知识，还有就是解决了求导这个工程较大的练习，让我更加有信心去面对接下来在学习中遇到的困难。


 








标签：总结,int,31,题集,month,year,day,输入	

来源： https://www.cnblogs.com/martin-wy/p/14617261.html