前三次题目集总结

时间：2021-04-04 22:46:55 阅读：52 评论：0 收藏：0 [点我收藏+]

前言

第一次题目集主要是为了增强java初学者对java操作与运行的熟练程度，了解掌握一些方法的使用。题量为8题，考察的知识点包括变量以及变量类型的创建，数字计算的程序，字符串的输入，使用（其中包括获得指定下标的字符）和比较（比如compareTo和equils等等），简单判断数据的if else语句的正确使用，判断复杂数据的switch语句在面对实际问题的正确使用和if语句的嵌套使用，一维数组的命名与建立，数组元素的排序，难度简单到中等。

第二次题目集在第一次题目集的基础之上增加了部分函数（Math里面的pow，Arrays里面的sort等等）与方法的使用，主方法与子方法的正确调用，参数的传递，多重if语句分类分析的数据，输入与输出的正确要求格式。题量为5，难度中等偏难，尤其后面三题循序渐进，有一定关系，对学生掌握同一种题目类型的不同问题求解有比较好的促进作用，更有利于学者锻炼思维分析，数据处理和分类讨论等等灵活的技能。

第三次题目集引入了java中面向对象重要理念的类的概念与使用，类的创建与类里面各种各样方法的建立，使用与调用。从这一次题目集开始，学者正式接触java语言的方便与强大之处，每一个题目都跟生活实例息息相关，银行账户的创建使用，日期的计算与查询，一元多项式的数学求导问题，这些能够帮助学者认识java生活中的应用，掌握面向对象服务化的思维分析方式。

设计与分析

（1）题目集一的7-8

（2）题目集二的7-4

（3）题目集二的7-5

（4）题目集三的7-2

（5）题目集三的7-3

（6）题目集二的7-1

（1）题目集一的7-8

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

输入格式:

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

输出格式:

（1）如果输入数据非法，则输出“Wrong Format”；

（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；

（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；

（4）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；

（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”3；

（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；

（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。

这道题只要对输入的三条边先判断是否形成三角形，然后再判断形成各种三角形的条件，使用多个if，else if语句即可，不过需要注意的是，判断直角三角形的条件这里最好不要用勾股定理，会有数据计算误差，应该换成a*a+b*b-c*c<0.00001类型，代码及相应注释如下：

import java.util.Scanner;//导入

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        float a = input.nextFloat();
        float b = input.nextFloat();
        float c = input.nextFloat();//输入三条边
        if((a>=1&&a<=200)&&(b>=1&&b<=200)&&(c>=1&&c<=200))//判断输入的数据是否合法
        {
            if((a+b<=c)||(a+c<=b)||(b+c<=a))//判断是否形成三角形
            {
                System.out.print("Not a triangle");
            }
            else
            {
                if((a==b)&&(b==c))//判断是否形成等边三角形
                {
                    System.out.println("Equilateral triangle");
                }
                else if(((a==b)&&(a*a+b*b-c*c<0.00001))||((a==c)&&(a*a+c*c-b*b<0.00001))||((b==c)&&(b*b+c*c-a*a<0.00001)))//判断是否形成等腰直角三角形
                {
                    System.out.print("Isosceles right-angled triangle");
                }
                else if((a==b)||(a==c)||(b==c))//判断是否形成等腰三角形
                {
                    System.out.print("Isosceles triangle");
                }
                else if((a*a+b*b-c*c<0.00001)||(a*a+c*c-b*b<0.00001)||(b*b+c*c-a*a<0.00001))//判断是否形成直角三角形
                {
                    System.out.print("Right-angled triangle");
                }
                else
                {
                    System.out.print("General triangle");
                }
            }
        }
        else
        {
            System.out.println("Wrong Format");
        }

    }
}

（1）题目集二的7-4

输入年月日的值（均为整型数），输出该日期的下一天。其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。

这道题的分析思路就是建立多个方法来对应需要的功能，比如构建

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)

来求输入日期的下一天

接下来就是写法的分析，闰年就是就是能被4整除且不能被100整除，或者能被400整除。

判断输入数据合法范围只需要一个if条件即可，求日期的下一天需要分析多种情况，如果是平年或者闰年的12月份的最后一天需要换到下一年，12月份之前的月份最后一天需要换到下一个月，还有输入的日期有没有超过这个月份的最后一天，总之需要十分谨慎，对于月份和日期的计算需要考虑清楚，一般情况自然简单，重要的是特殊情况，这些也是测试点所在。相关代码及注释如下：

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int year=input.nextInt();
        int month=input.nextInt();
        int day=input.nextInt();//输入年，月，日
        nextDate(year,month,day);//调用求下一天的方法
    }//主方法
    public static boolean isLeapYear(int year) {
        if((year%4==0&&year%100!=0)||(year%400==0)) {
            return true; }
        else {
            return false; }
    }//判断year是否为闰年，返回boolean类型
    public static boolean checkInputValidity(int year,int month,int day){
        if((year>=1820&&year<=2020)&&(month>=1&&month<=12)&&(day>=1&&day<=31)) {
            return true; }
        else {
            return false; }
    }//判断输入日期是否合法，返回布尔值
    public static void nextDate(int year,int month,int day) {
        int[] a=new int[13];int[] b=new int[13];int x=0,y=0,z=0;//定义两个存储闰年和平年的月份天数的数组
        a[1]=31;a[2]=29;a[3]=31;a[4]=30;a[5]=31;a[6]=30;a[7]=31;a[8]=31;a[9]=30;a[10]=31;a[11]=30;a[12]=31;//存放闰年月份天数
        b[1]=31;b[2]=28;b[3]=31;b[4]=30;b[5]=31;b[6]=30;b[7]=31;b[8]=31;b[9]=30;b[10]=31;b[11]=30;b[12]=31;//存放平年月份天数
        if(checkInputValidity(year,month,day)) {
            if(isLeapYear(year)) {
                if(month==12) {
                    if(day==a[month]) {
                        x=year+1;
                        y=1;
                        z=1; }//12月最后一天
                    if(day>=1&&day<a[month]) {
                        x=year;
                        y=month;
                        z=day+1; } }//12月某一天
                if(month!=12) {
                    if(month==2&&day>a[2]) {
                        System.out.print("Wrong Format"); }//超过月份最后一天
                    else {
                        if(day==a[month]) {
                            x=year;
                            y=month+1;
                            z=1; }//某月最后一天
                        if(day>=1&&day<a[month]) {
                            x=year;
                            y=month;
                            z=day+1;//某月某一天 } } } }
            else {
                if(month==12) {
                    if(day==b[month])//12月最后一天 {
                        x=year+1;
                        y=1;
                        z=1; }
                    if(day>=1&&day<b[month]) {
                        x=year;
                        y=month;
                        z=day+1; } }
                if(month!=12) {
                    if(month==2&&day>b[2])//超过月份最后一天 {
                        System.out.print("Wrong Format");
                    System.exit(0);}
                    else {
                        if(day==b[month]) //某月最后一天{
                            x=year;
                            y=month+1;
                            z=1; }
                        if(day>=1&&day<b[month]) //某月某一天{
                            x=year;
                            y=month;
                            z=day+1; } } } }
            System.out.print("Next date is:"+x+"-"+y+"-"+z); }
        else {
            System.out.print("Wrong Format"); }
    }//求输入日期的下一天
}

（1）题目集二的7-5

输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。

注意：不允许使用Java中任何与日期有关的类或方法。

这一题应该是建立在是建立在7-4题目的基础之上，只不过添加了一个n，这个n除了范围，也有可能是正值与负值，麻烦的是，现在不是加一天，而是加n天，如果跨月份，需要减去上一月份的天数，跨年亦是如此，当n为负值，减法实际也差不多，注重月份和年份跨越，其他的一般情况直接写也就可以了

这道题的分析思路也是要建立多个方法来对应需要的功能，比如构建

public static boolean isLeapYear(int year)

来判断year是否为闰年，返回boolean类型

public static boolean checkInputValidity(int year,int month,int day)

来判断输入日期是否合法，返回布尔值

public static void TheNextDate(int year,int month,int day)

来求输入日期的下一天

相关代码及注释如下：

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int year=input.nextInt();
        int month=input.nextInt();
        int day=input.nextInt();
        int n=input.nextInt();
        if(Checkdata( year, month, day, n))
        {
            TheNextDay( year, month, day, n);
        }
        else
        {
            System.out.print("Wrong Format");
        }

    }


    //判断闰年
    public static boolean isLeapYear(int year){
        if((year%4==0&&year%100!=0)||(year%400==0))
        {
            return true;
        }
        else
        {
            return false;
        }
    }


    //判断数据是否合法

    public static boolean Checkdata(int year,int month,int day,int n){
        int[] a=new int[13];
        a[1]=31;
        a[2]=28;
        a[3]=31;
        a[4]=30;
        a[5]=31;
        a[6]=30;
        a[7]=31;
        a[8]=31;
        a[9]=30;
        a[10]=31;
        a[11]=30;
        a[12]=31;
        if(isLeapYear(year))
        {
            a[2]=29;
        }
        if((year>=1820&&year<=2020)&&(month>=1&&month<=12)&&(day>=1&&day<=a[month])&&(n>=-10&&n<=10))
        {
            return true;
        }
        else
        {
            return false;
        }
    }


    //求日期

    public static void TheNextDay(int year,int month,int day,int n){
        int[] a=new int[13];
        a[1]=31;
        a[2]=28;
        a[3]=31;
        a[4]=30;
        a[5]=31;
        a[6]=30;
        a[7]=31;
        a[8]=31;
        a[9]=30;
        a[10]=31;
        a[11]=30;
        a[12]=31;
        if(isLeapYear(year))
        {
            a[2]=29;
        }
        day-=n;
        if(n>0)
        {
            if(day<=0)
            {
                month--;
                if(month==0)
                {
                    month+=12;
                    year--;
                }
            }
            day+=a[month];
        }
        if(n<0)
        {
            if(day>a[month])
            {
                day-=a[month];
                month++;
                if(month==13)
                {
                    month-=12;
                    year++;
                }
            }
        }
        System.out.printf("%d days ago is:%d-%d-%d",n,year,month,day);
    }

}

4）题目集三的7-2

定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。

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

这里除了主类，还要构建一个Date类，用于储存三个私有属性的对象，以及三个对象的访问器以及修饰器，其次还有判断闰年和平年的方法，判断输入数据是否符合要求的方法，求下一天的方法一并放入这个类中，然后注意在主类中调用这个Date类中的方法就可以了，因为对象是私有型，并不能直接用，这一点需要注意，不要犯低级错误。还有在主类中创建这个Date类，才能使用Date里的方法，不然编译器会找不到date类。

这里应用了类与类的调用，类中的方法对应相应的功能

比如构建

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)

来求输入日期的下一天

class Date{

private int year;//私有属性年份

private int month;//私有属性月份

private int day;//私有属性日期

//static int[] a={31,29,31,30,31,30,31,31,30,31,30,31};

//static int[] b={31,28,31,30,31,30,31,31,30,31,30,31};

相关代码及注释如下

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int year=input.nextInt();
        int month=input.nextInt();
        int day=input.nextInt();

        Date date=new Date();
        boolean i= date.checkInputValidity(year,month,day);
        if(i)
        {
            date.getNextDate(year,month,day);
        }
        else
        {
            System.out.print("Date Format is Wrong");
        }
    }
    

}

class Date{
    private int year;//私有属性年份
    private int month;//私有属性月份
    private int day;//私有属性日期
    //static int[] a={31,29,31,30,31,30,31,31,30,31,30,31};
    //static int[] b={31,28,31,30,31,30,31,31,30,31,30,31};



    Date(){

    }//无参构建


    Date(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }//修饰器赋值

    public int getYear(){
        return year;
    }


    public void setYear(int year){
        this.year=year;
    }


    public int getMonth(){
        return month;
    }

    public void setMonth(int month){
        this.month=month;
    }

    public int getDay(){
        return day;
    }

    public void setDay(int day){
        this.day=day;
    }



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


    public boolean checkInputValidity(int year,int month,int day){
        if((year>=1900&&year<=2000)&&(month>=1&&month<=12)&&(day>=1&&day<=31)) {
            return true; }
        else {
            return false; }
    }//判断输入日期是否合法，返回布尔值


    public void getNextDate(int year,int month,int day) {
        int[] a=new int[13];int[] b=new int[13];
        int x=0,y=0,z=0;
        a[1]=31;a[2]=29;a[3]=31;a[4]=30;a[5]=31;a[6]=30;a[7]=31;a[8]=31;a[9]=30;a[10]=31;a[11]=30;a[12]=31;
        b[1]=31;b[2]=28;b[3]=31;b[4]=30;b[5]=31;b[6]=30;b[7]=31;b[8]=31;b[9]=30;b[10]=31;b[11]=30;b[12]=31;
        //int[] a={31,29,31,30,31,30,31,31,30,31,30,31};
        //int[] b={31,28,31,30,31,30,31,31,30,31,30,31};
        if(checkInputValidity(year,month,day)) {
            if(isLeapYear(year)) {
                if(month==12) {
                    if(day==a[month]) {
                        x=year+1;
                        y=1;
                        z=1; }
                    if(day>=1&&day<a[month]) {
                        x=year;
                        y=month;
                        z=day+1; } }
                if(month!=12) {
                    if(month==2&&day>a[2]) {
                        System.out.print("Date Format is Wrong"); }
                    else {
                        if(day==a[month]) {
                            x=year;
                            y=month+1;
                            z=1; }
                        if(day>=1&&day<a[month]) {
                            x=year;
                            y=month;
                            z=day+1; } } } }
            else {
                if(month==12) {
                    if(day==b[month]) {
                        x=year+1;
                        y=1;
                        z=1; }
                    if(day>=1&&day<b[month]) {
                        x=year;
                        y=month;
                        z=day+1; } }
                if(month!=12) {
                    if(month==2&&day>b[2]) {
                        System.out.print("Date Format is Wrong");
                        System.exit(0);}
                    else {
                        if(day==b[month]) {
                            x=year;
                            y=month+1;
                            z=1; }
                        if(day>=1&&day<b[month]) {
                            x=year;
                            y=month;
                            z=day+1; } } } }
            System.out.print("Next day is:"+x+"-"+y+"-"+z); }
        else {
            System.out.print("Date Format is Wrong"); }
    }//求输入日期的下一天
}

（1）题目集三的7-3

编写程序性，实现对简单多项式的导函数进行求解。

这个题目很多人说要用到正则表达式，用于一类指定字符串的获得，然后不断的使用equils和compareTo函数，求导步骤使用数学知识，对于多项式前面的系数需要分类讨论，正值，0，负值都有不同的处理。

（2）题目集二的7-1

一个IP地址是用四个字节（每个字节8位）的二进制码组成。请将32位二进制码表示的IP地址转换为十进制格式表示的IP地址输出。

输入数据要求：

必须为二进制数，即只能输入0或者1
长度必须是32位

违背以上规则程序直接输出Wrong Format

这里对于字符串的理解更深了，length（）用于计算字符串的长度规定，还有charAt函数用于获得特定的字符，还有Math.pow函数用于幂运算，注意写法，就应该没有问题。

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        String s = input.nextLine();
        int a=0;
        int b=0;
        int c=0;
        int d=0;
        if(s.length()!=32)
        {
            System.out.print("Wrong Format");
            return;
        }
        char[] ch = new char[32];
        for(int i=0;i<32;i++)
        {
            if(s.charAt(i)!=‘1‘&&s.charAt(i)!=‘0‘)
            {
                System.out.print("Wrong Format");
                return;
            }
            else
            {
                ch[i]=s.charAt(i);
            }
        }
        for(int j=0;j<8;j++)
        {
            if(ch[j]!=‘0‘)
            {
                a+=Math.pow(2,(7-j));
            }
        }
        for(int k=8;k<16;k++)
        {
            if(ch[k]!=‘0‘)
            {
                b+=Math.pow(2,(15-k));
            }
        }
        for(int m=16;m<24;m++)
        {
            if(ch[m]!=‘0‘)
            {
                c+=Math.pow(2,(23-m));
            }
        }
        for(int n =24;n<32;n++)
        {
            if(ch[n]!=‘0‘)
            {
                d+=Math.pow(2,(31-n));
            }
        }
        System.out.print(a+"."+b+"."+c+"."+d);
    }
}

采坑心得

（1）题目集一的7-8

else if(((a==b)&&(a*a+b*b-c*c<0.00001))||((a==c)&&(a*a+c*c-b*b<0.00001))||((b==c)&&(b*b+c*c-a*a<0.00001)))//判断等腰直角三角形

{

System.out.print("Isosceles right-angled triangle");//输出等腰直角三角形

}

else if((a*a+b*b-c*c<0.00001)||(a*a+c*c-b*b<0.00001)||(b*b+c*c-a*a<0.00001))//判断直角三角形

{

System.out.print("Right-angled triangle");//输出直角三角形

这个题目刚开始做的时候只需要写好这些判断条件就可以了，在编译器上写完之后可以运行，就自信满满地去提交，然后发现一个关于直角三角形的点没过，因为我之前写的时候用的是勾股定理判断直角三角形，写出来是这样的

else if(((a==b)&&(a*a+b*b==c*c))||((a==c)&&(a*a+c*c==b*b))||((b==c)&&(b*b+c*c==a*a)))//判断等腰直角三角形

{

System.out.print("Isosceles right-angled triangle");//输出等腰直角三角形

}

else if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(b*b+c*c==a*a))//判断直角三角形

{

System.out.print("Right-angled triangle");//输出直角三角形

写完之后我以为没什么问题，结果却十分迷惑，后来发现其他同学也是这种情况，接下来通过网上查询和请教老师才知道这是编译器的数值误差，其实勾股定理压根没错，但编译器没办法将一些特殊边长的直角三角形涵盖在内，怎么理解呢？比如1，根号2，根号3，可以形成直角三角形，但编译器不能识别根号，它会保留6位小数，这样的话计算有误差，无法满足勾股定理。所以要换成上面的写法，才能通过测试点。

总结来说还是不够了解java体系的一些例子，认真一点，好问一点基本能够完成

技术分享图片

（1）题目集二的7-4

int[] a=new int[13];int[] b=new int[13];int x=0,y=0,z=0;

a[1]=31;a[2]=29;a[3]=31;a[4]=30;a[5]=31;a[6]=30;a[7]=31;a[8]=31;a[9]=30;a[10]=31;a[11]=30;a[12]=31;

b[1]=31;b[2]=28;b[3]=31;b[4]=30;b[5]=31;b[6]=30;b[7]=31;b[8]=31;b[9]=30;b[10]=31;b[11]=30;b[12]=31;

刚开始写的时候我本来只想用一个数组a[]，之后加一个判断闰年，如果不是闰年，就把a[2]重新赋值为28，其他存储月份的值不变，

int[] a=new int[13];int x=0,y=0,z=0;

a[1]=31;a[2]=28;a[3]=31;a[4]=30;a[5]=31;a[6]=30;a[7]=31;a[8]=31;a[9]=30;a[10]=31;a[11]=30;a[12]=31;

If(isLeapYear(year))

{

a[2]=29;

}

可后来写着写着感觉很麻烦，总是会搞错，就注释掉了麻烦的步骤，干脆用两个数组来分别储存平年闰年的月份天数，写起来就顺畅了，只需要注意月份和天数的转换就可以了.

检查无误之后提交发现有两个点没过，是平年2月29日和平年2月28日，这应该是那个

错误数据和平年2月28之后一天输出为3月1日没考虑好，所以我就在平年2月份那里专门给出一个if语句处理这个超过29的错误数据，因为输入的天是1-31，所以完全有可能大于29

if(month==2&&day>b[2]) {

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

System.exit(0);}

后来平年2月28日这个点还没过，就有点纳闷，查看过程中我总是盯着是不是12月份转到下一年没写好，还是天数等于月末的时候转到下个月没写好，都头来原来是闰年那里2月29日也要跟平年一样给个判断

if(month==2&&day>a[2]) {

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

这样就可以了。

总结来说，注意判断月份和年份的递进，保障错误数据的判断，过程仔细，应该没多大问题。

题目集二的7-5

if(Checkdata( year, month, day, n))//判断输入数据是否合法

{

TheNextDay( year, month, day, n);//求下一天

}

else

{

System.out.print("Wrong Format");//输出数据错误

}

写完之后用测试样例测试，没问题就提交，结果无效边界测试全部没过，仔细找了找发现main那里我是直接写了

TheNextDay( year, month, day, n);//求下一天

而没有输出错误数据的判断，只有换成上面写法，才能不遗漏。

由于此题建立在7-4题目基础之上，所以比较轻松。

int[] a=new int[13];

a[1]=31;

a[2]=28;

a[3]=31;

a[4]=30;

a[5]=31;

a[6]=30;

a[7]=31;

a[8]=31;

a[9]=30;

a[10]=31;

a[11]=30;

a[12]=31;

if(isLeapYear(year))

{

a[2]=29;

}

这里我又换成一个数组的方法，在这里比较合适，简便快捷，其次顺序结构比较清晰，比较容易理解，其次还要注意输出方式

（1）题目集三的7-2

技术分享图片

boolean i= date.checkInputValidity(year,month,day);

if(i)

{

date.getNextDate(year,month,day);

}

else

{

System.out.print("Date Format is Wrong");

}

一开始我又是只写了

date.getNextDate(year,month,day);

结果那些无效边界值又没输出，boolean i= date.checkInputValidity(year,month,day);

用于调用date中方法的返回值。

Date date=new Date();之前没有写这个，导致找不到Date类

（1）题目集7-1

if(s.charAt(i)!=‘1‘&&s.charAt(i)!=‘0‘)

{

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

return;

}

这里之前没有加return，导致程序无法停止，草率了。

技术分享图片

改进建议

题目集一的7-8其实还可以再加入锐角三角形和钝角三角形的判断

题目集二的7-4其实对于空数据的处理还不够完善，建议改进对各种误差数据的判断

总结

通过这几次题目集的学习理解，我了解了部分重要应用的方法和函数，对于程序的运行有了更为标准的调试，Math，charAt,SubString,equils,compareTo,langth,方法的使用不断深入，类与类调用，对象属性有了更深的理解。每一次的测试都是十分的艰辛，但也十分有趣。

面向对象的编程思想不是一朝一夕能实现的，需要不断的动手尝试，阅读高质量的优秀代码，才能不断的提升。希望与我有同样问题的同学能再接再励，利用这次写博客的时间好好反思，好好整理心情，该出去踏青的时间就不要在学校里苦干写不完的作业，这样其实效率很低（个人亲测）。一次挫折并不影响昆仑历练的成功，不要被困难击退，重整旗鼓，迎难而上。谢谢观看！

前三次题目集总结

原文：https://www.cnblogs.com/muyuchengfeng/p/14616332.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)