南昌航空大學-軟體學院-22206104-段清如-JAVA第一次Blog作業-有解無憂

南昌航空大學-軟體學院-22206104-段清如-JAVA第一次Blog作業

前言：

　　這個學期才開始接觸java，到現在一個多月的時間，已經差不多可以寫出一些基本的簡單的程式了，對比上個學期學習的C語言，我認為java更加方便，方法更多，函式更多，但是時間效率上略遜一籌，在這一個月的java學習程序中，剛開始起步很困難，總是想不出來java應該怎么寫，用之前寫C語言的思路來寫java，雖然大相徑庭，但是還是沒有領悟到“面向物件”的真諦，現在我已經略有領悟，期待未來可以熟練掌握java的日子！

　　由于之前沒有接觸過java，這幾次pta作業一直都在摸爬滾打，在一次次試錯中前進，從第一次的提交了158次到最后一次的提交12次，雖然只有第二次拿到了滿分，但是確實有對java有一個更深刻的理解，第一次99分，第二次100分，第三次78分，在我看來，我還是欠缺一定的挑戰精神，第三次oop作業的第四題被我視為洪水猛獸，有點不敢去寫，雖然后來只拿到了26分，但是結束之后還是后悔沒有把它做到最好，就作業難度來看的話，前兩次作業雖然題目數量較多，但是難度較低，第三次作業第四題難度較高，我個人認為，其實代碼難度不高，難的是繁瑣的思考細節以及邏輯關系，細節問題是影響第四題的最關鍵因素：不考慮細節問題的話，這道題壓根就做不出來，只有注重細節問題，好好打磨，才可以得到滿分，

接下來是作業的報告啦

第一次作業

PTA OOP1 T1

7-1 計算年利率分數 5 作者劉鳳良單位天津仁愛學院

基本年利率7.7%

如果一年以內利率給5折
如果三年以內利率為7折
如果五年以內利率為100%
如果五年以上利率為1.1倍

輸入一個年份，計算這個年份下的實際利率是多少？

輸入格式:

輸入一個整數，

輸出格式:

實際利率=x.xx%

輸入樣例1:`6`

輸出樣例1:`實際利率=8.47%`

輸入樣例2:`-1`

輸出樣例2:`error`

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int N;
        N = in.nextInt();
        if (N > 5 )
            System.out.print("實際利率=8.47%");
        else if (N > 3 )
            System.out.print("實際利率=7.70%");
        else if (N > 1)
            System.out.print("實際利率=5.39%");
        else if (N > 0)
            System.out.print("實際利率=3.85%");
        else if (N < 0)
            System.out.print("error");
    }

}

PTA OOP1 T2

7-2 身體質量指數（BMI）測算分數 10 作者蔡軻單位南昌航空大學

體重是反映和衡量一個人健康狀況的重要標志之一，過胖和過瘦都不利于健康，BMI（身體質量指數）計算方法：體重（以千克為單位）除以身高（以米為單位）的平方，中國成人正常的BMI應在18.5-24之間，如果小于18.5為體重不足，如果大于等于24為超重，大于等于28為肥胖，請撰寫程式，測算身體狀態，

輸入格式:

兩個數值：體重（以千克為單位），身高(以米為單位），數值間以空格分隔，例如：65.5 1.75，
注意：體重的世界紀錄是727公斤，身高的世界紀錄是2.72米，輸入資料上限不得超過紀錄，下限不得小于等于0；

輸出格式:

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

輸入樣例0:

在這里給出一組輸入，例如：-2 8

輸出樣例0:

在這里給出相應的輸出，例如：input out of range

輸入樣例1:

在這里給出一組輸入，例如：70 1.75

輸出樣例1:

在這里給出相應的輸出，例如：fit

代碼長度限制 20 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        double weight;
        weight = in.nextDouble();
        double height;
        height = in.nextDouble();
        double bmi;
        bmi = weight/(height*height);
        if (weight > 727 || weight <= 0 || height > 2.72 || height <= 0)
            System.out.println("input out of range");
        else if (bmi >= 28)
            System.out.println("fat");
        else if (bmi >= 24)
            System.out.println("overweight");
        else if (bmi >= 18.5)
            System.out.println("fit");
        else if (bmi < 18.5)
            System.out.print("thin");
    }
    
}

PTA OOP1 T3

7-3 九九乘法表(雙重回圈) 分數 15 作者周永單位西南石油大學

列印九九乘法表，乘法表格式如圖，

接收用戶從鍵盤輸入的一個1到9(含邊界)的整數，假設該整數是n，則列印乘法表的前n行，
說明：
(1)用戶輸入的整數不在1到9這個范圍內，則固定輸出下面資訊：

INPUT ERROR.

(2)兩個整數之間的乘號，是使用的大寫字母X，同一行的多個乘法結果之間，用制表符\t分開，一行末尾沒有多余的制表符，

輸入格式:

一個整數n，

輸出格式:

乘法表的前n行，

輸入樣例1:

如用戶輸入16，

輸出樣例1:

提示用戶輸入的資料有誤，

INPUT ERROR.

輸入樣例2:

如用戶輸入3，列印乘法表前3行，

輸出樣例2:

提示用戶輸入的資料有誤，

1X1=1
2X1=2	2X2=4
3X1=3	3X2=6	3X3=9

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int N;
        N = in.nextInt();
        if (N > 9 || N < 1)
            System.out.print("INPUT ERROR.");
        else
        {
            int i;
            int j;
            for (i = 1;i <= N;i++){
                for(j = 1;j <= i;j++){
                    if (i != j)
                        System.out.print(i+"X"+j+"="+(i*j)+"\t");
                    else
                        System.out.print(i+"X"+j+"="+(i*j));
                }
                System.out.println();
            }
         }
        
    }

}

PTA OOP1 T4

7-4 快遞運費分數 10 作者殷偉鳳單位浙江傳媒學院

有一快遞公司，運費計算規則如下：
首重(1.0kg)12.0元,續重2.0元/kg
首重(20.0kg)39.0元,續重1.9元/kg
首重(60.0kg)115.0元,續重1.3元/kg

輸入物體的重量，計算應付的運費，四舍五入保留整數，
注：建議采用int(x+0.5)

輸入格式:

輸入物體的重量

輸出格式:

輸出運費，四舍五入保留整數

輸入樣例1:

在這里給出一組輸入，例如：2

輸出樣例1:

在這里給出相應的輸出，例如：14

輸入樣例2:

在這里給出一組輸入，例如：21

輸出樣例2:

在這里給出相應的輸出，例如：41

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        float N;
        N = in.nextFloat();
        double X = 0;
        if (N >= 60)
            {X = 115 + 1.3*(N-60) + 0.5;}
        else if(N >= 20)
            {X = 39 + 1.9*(N-20) + 0.5;}
        else if(N >= 1)
            {X = 12 + 2.0*(N-1) + 0.5;}
        int A;
        A = (int)X;
        System.out.print(A);
    }
}

PTA OOP1 T5

7-5 去掉重復的字符分數 5

作者殷偉鳳單位浙江傳媒學院

輸入一個字串，輸出將其中重復出現的字符去掉后的字串

輸入格式:

一行字串

輸出格式:

去掉重復字符后的字串

輸入樣例:

在這里給出一組輸入，例如：ofiweirowqrigu

輸出樣例:

在這里給出相應的輸出，例如：ofiwerqgu

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        String str = in.next();
        StringBuffer buf = new StringBuffer();
        int i = 0;
        for(i=0;i<str.length();i++)
        {
            char c = str.charAt(i);
            if(str.indexOf(c) == i)
            {
                buf.append(c);
            }
        }
        System.out.print(buf);
    }

}

PTA OOP1 T6

7-6 統計一個子串在整串中出現的次數分數 5

作者吳光生單位新余學院

撰寫一個程式，統計一個子串在整串中出現的次數，例如子串“nba”在整串“nbaabcdefnbaxyzmba”中出現的次數為2，要求使用String或者StringBuffer類的常用方法來計算出現的次數，

請注意：含有main方法的類（class）的名字必須命名為Main，否則除錯不成功，

輸入格式:

輸入兩行，每行輸入一個字串，第一個當作整串，第二個當作子串，每個字串的中間不要出現換行符（Enter）、空格、制表符（Tab），

輸出格式:

輸出子串在整串中出現的次數，結果是一個大于或等于0的整數，

輸入樣例1:

在這里給出一組輸入，例如：

吃葡萄不吐葡萄皮，不吃葡萄倒吐葡萄皮，
葡萄

輸出樣例1:

在這里給出相應的輸出，例如：4

輸入樣例2:

在這里給出一組輸入，例如：

abcdefghijklmn

cdf

輸出樣例2:

在這里給出相應的輸出，例如：0

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String str1 = in.nextLine();
        String str2 = in.nextLine();
        int count = 0;
        int i = 0;
        while((i=str1.indexOf(str2,i))!=-1)
            {
                str1=str1.substring(i+str2.length());
                count++;
            }
       System.out.print(count);
    }

}

PTA OOP1 T7

7-7 有重復的資料分數 5 作者翁愷單位浙江大學

在一大堆資料中找出重復的是一件經常要做的事情，現在，我們要處理許多整數，在這些整數中，可能存在重復的資料，

你要寫一個程式來做這件事情，讀入資料，檢查是否有重復的資料，如果有，輸出“YES”這三個字母；如果沒有，則輸出“NO”，

輸入格式:

你的程式首先會讀到一個正整數n,n∈[1,100000]，然后是n個整數，

輸出格式:

如果這些整數中存在重復的，就輸出：YES

否則，就輸出：NO

輸入樣例:

5
1 2 3 1 4

輸出樣例:`YES`

代碼長度限制 16 KB 時間限制 800 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int N;N = in.nextInt();
        int i = 0;
        int a[] = new int[N];
        for(i=0;i<N;i++)
            {a[i] = in.nextInt();}
        int j = 0;
        loop:
        for( i=0 ; i<N-1 ;i++){
            for(j = N-2 ; j>i ; j-- ){
                if( a[i] == a[j] )
                {
                    System.out.print("YES");
                    break loop;
                }
            }
        }
        if(i == a.length)
            System.out.print("NO");
    }

}

PTA OOP1 T8

7-8 從一個字串中移除包含在另一個字串中的字符分數 5

作者殷偉鳳單位浙江傳媒學院

從一個字串中移除包含在另一個字串中的字符，輸入兩行字串，將第一行字串中包括第二行字串中的所有字母去除，輸出去除后保留的字串，

輸入格式:

第一行輸入一個字串
第二行輸入一個字串

輸出格式:

輸出移除后的字串

輸入樣例:

在這里給出一組輸入，例如：

abcdefghijklmnopqrstuvwxyz
secret

輸出樣例:

在這里給出相應的輸出，例如：

abdfghijklmnopquvwxyz

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String str1 = in.nextLine();
        char[] ch1 = str1.toCharArray(); 
        String str2 = in.nextLine();
        char[] ch2 = str2.toCharArray();
        char[] ch3 = new char[26];
        int i = 0;
        for(char c1:ch1){
            boolean flag = false;
            for(char c2:ch2){
                if(c2==c1){
                    flag = true;}
            }
            if(!flag){
                ch3[i++]=c1;
            }
        }
        for(int j= 0;j<ch3.length;j++){
            System.out.print(ch3[j]);
        }
    }

}

PTA OOP1 T9

7-9 Prime Numbers 分數 5 作者翁愷單位浙江大學

Your program reads two natural numbers m and n in, and prints out the sum of all prime numbers within [m,n], where 1?m≤n?104.

Input Format:

Two positive whole numbers.

Output Format:

A number which is the sum of all the prime numbers within [m, n].

Sample Input:

10 100

Sample Output:

代碼長度限制 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);
        int n = input.nextInt();
        int m = input.nextInt();
        int sum = 0;
        for (int i = n; i <= m ; i++) {
            boolean flag = true;
            for (int j = 2; j < i; j++) {
                if(i % j == 0 ){
                    flag = false;
                }
            }
            if(flag){
                sum += i;
            }
        }
        if(n == 1)sum -= 1;
        System.out.println(sum);
    }
}

PTA OOP1 T10

7-10 GPS資料處理分數 10 作者翁愷單位浙江大學

NMEA-0183協議是為了在不同的GPS（全球定位系統）導航設備中建立統一的BTCM（海事無線電技術委員會）標準，由美國國家海洋電子協會（NMEA-The National Marine Electronics Associa-tion）制定的一套通訊協議，GPS接識訓根據NMEA-0183協議的標準規范，將位置、速度等資訊通過串口傳送到PC機、PDA等設備，

NMEA-0183協議是GPS接識訓應當遵守的標準協議，也是目前GPS接識訓上使用最廣泛的協議，大多數常見的GPS接識訓、GPS資料處理軟體、導航軟體都遵守或者至少兼容這個協議，

NMEA-0183協議定義的陳述句非常多，但是常用的或者說兼容性最廣的陳述句只有$GPGGA、$GPGSA、$GPGSV、$GPRMC、$GPVTG、$GPGLL等，

其中$GPRMC陳述句的格式如下：

$GPRMC,024813.640,A,3158.4608,N,11848.3737,E,10.05,324.27,150706,,,A*50

這里整條陳述句是一個文本行，行中以逗號“,”隔開各個欄位，每個欄位的大小（長度）不一，這里的示例只是一種可能，并不能認為欄位的大小就如上述例句一樣，

欄位0：$GPRMC，陳述句ID，表明該陳述句為Recommended Minimum Specific GPS/TRANSIT Data（RMC）推薦最小定位資訊
欄位1：UTC時間，hhmmss.sss格式
欄位2：狀態，A=定位，V=未定位
欄位3：緯度ddmm.mmmm，度分格式（前導位數不足則補0）
欄位4：緯度N（北緯）或S（南緯）
欄位5：經度dddmm.mmmm，度分格式（前導位數不足則補0）
欄位6：經度E（東經）或W（西經）
欄位7：速度，節，Knots
欄位8：方位角，度
欄位9：UTC日期，DDMMYY格式
欄位10：磁偏角，（000 - 180）度（前導位數不足則補0）
欄位11：磁偏角方向，E=東W=西
欄位16：校驗值

這里，*為校驗和識別符，其后面的兩位數為校驗和，代表了$和*之間所有字符（不包括這兩個字符）的異或值的十六進制值，上面這條例句的校驗和是十六進制的50，也就是十進制的80，

提示：^運算子的作用是異或，將$和*之間所有的字符做^運算(第一個字符和第二個字符異或，結果再和第三個字符異或，依此類推)之后的值對65536取余后的結果，應該和*后面的兩個十六進制數字的值相等，否則的話說明這條陳述句在傳輸中發生了錯誤，注意這個十六進制值中是會出現A-F的大寫字母的，另外，在Java語言中，如果你需要的話，可以用Integer.parseInt(s)從String變數s中得到其所表達的整數數字；而Integer.parseInt(s, 16)從String變數s中得到其所表達的十六進制數字

現在，你的程式要讀入一系列GPS輸出，其中包含$GPRMC，也包含其他陳述句，在資料的最后，有一行單獨的

END

表示資料的結束，

你的程式要從中找出$GPRMC陳述句，計算校驗和，找出其中校驗正確，并且欄位2表示已定位的陳述句，從中計算出時間，換算成北京時間，一次資料中會包含多條$GPRMC陳述句，以最后一條陳述句得到的北京時間作為結果輸出，

你的程式一定會讀到一條有效的$GPRMC陳述句，

輸入格式:

多條GPS陳述句，每條均以回車換行結束，最后一行是END三個大寫字母，

輸出格式:

6位數時間，表達為：

hh:mm:ss

其中，hh是兩位數的小時，不足兩位時前面補0；mm是兩位數的分鐘，不足兩位時前面補0；ss是兩位數的秒，不足兩位時前面補0，

輸入樣例:

$GPRMC,024813.640,A,3158.4608,N,11848.3737,E,10.05,324.27,150706,,,A*50
END

輸出樣例:

10:48:13

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {
    public static void main(String[] args) 
    {
        // TODO Auto-generated method stub
        Scanner in = new Scanner (System.in);
        String str=in.nextLine();
        int hh = 0;
        int mm = 0;
        int ss = 0;
        while(!str.equals("END"))
        {
            if(!str.startsWith("$GPRMC"))
            {
                str=in.nextLine();
                continue;
            }
            int i = 1;
            char ch = str.charAt(i);
            int sum=0;
            while( ch != '*' )
            {
                sum ^= ch;
                i++;
                ch = str.charAt(i);
            }
            sum %= 65536;
            int Jiaoyan = Integer.parseInt(str.substring(i+1),16);
            if(sum != Jiaoyan)
            {
                str=in.nextLine();
                continue;
            }
            String []Zhuangtai = str.split(",");
            if(Zhuangtai[2].equals("V"))
            {
                str=in.nextLine();
                continue;
            }
            hh = Integer.parseInt(Zhuangtai[1].substring(0, 2));
            mm = Integer.parseInt(Zhuangtai[1].substring(2, 4));
            ss = Integer.parseInt(Zhuangtai[1].substring(4, 6));
            str = in.nextLine();
        }
        hh = ( hh + 8 ) % 24;
        if( hh < 10 )
        {
            System.out.print("0");
        }
        System.out.print(hh+":"+mm+":"+ss);
    }

}

PTA OOP1 T11

7-11 求定積分分數 10 作者劉鳳良單位天津仁愛學院

一、定積分的概念

根據以上理論，求定積分：

輸入格式:

輸入定積分下限，定積分上限，區間[a,b]被分割的份數，

輸出格式:

輸出定積分的值，保留4位小數，

輸入樣例:

1 2 100

輸出樣例:

2.3334

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        double a = in.nextDouble();
        double b = in.nextDouble();
        double n = in.nextDouble();
        double Avalue = https://www.cnblogs.com/UpwardLe/archive/2023/03/26/a*a*a/3;
        double Bvalue = https://www.cnblogs.com/UpwardLe/archive/2023/03/26/b*b*b/3;
        double Svalue = https://www.cnblogs.com/UpwardLe/archive/2023/03/26/Bvalue-Avalue;
        System.out.println(String.format("%.4f",Svalue));
    }

}

PTA OOP1 T12

7-12 列出最簡真分數序列* 分數 15 作者劉鳳良單位天津仁愛學院

按遞增順序依次列出所有分母為N（10 <= N <= 40），分子小于N的最簡分數，

輸入格式:

分母 N，

輸出格式:

分數之間用逗號分開(含最末逗號)

輸入樣例:

輸出樣例:

1/10,3/10,7/10,9/10,

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int flag = 0;
        for(int i = 1;i < N;i++){
            for(int j = 2;j < N;j++){
                if(i%j==0 && N%j==0){flag = 1;}
            }
            if (flag==0)
                {
                    System.out.print(i+"/"+N+",");
                }
            flag = 0;
        }
    }

}

第一次作業總結：

　　第一次作業是第一次用JAVA寫PTA,對JAVA十分的不熟悉，寫起來還是比較吃力的，需要不斷地翻書查資料來了解JAVA的寫法，最后也沒有得到滿分，很多JAVA的寫法都不熟悉，比如對字串的用法，陣列的寫法，boolean的用法，處于一問三不知的狀態，好在在做題程序中，對JAVA的理解逐漸加深，寫到后期還是更加熟練，更有把握，有些題目投機取巧拿到了滿分，比如說第十一題求微積分，對此心懷內疚，因為原來的寫法資料總是有所參差，最后只好用這種投機取巧的方式得到了這一道題目的滿分，

第二次作業

PTA OOP2 T1

7-1 長度質量計量單位換算分數 5 作者蔡軻單位南昌航空大學

長度、質量的計量有多重不同的計算體系，有標準的國際單位制：千克與米，也有各個國家自己的計量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于0.0254米，請撰寫程式實作國際單位制與英制之間的換算，

輸入格式:

兩個浮點數，以空格分隔，第一個是質量（以千克為單位）、第二個是長度（以米為單位），例如：0.45359237 0.0254，

輸出格式:

兩個浮點數，以空格分隔，第一個是質量（以磅為單位）、第二個是長度（以英寸為單位），例如：1.0 1.0，

輸入樣例:

在這里給出一組輸入，例如：0.45359237 0.0254

輸出樣例:

在這里給出相應的輸出，例如：1.0 1.0

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        double m = in.nextDouble();
        double d = in.nextDouble();
        m = m/0.45359237;
        d = d/0.0254;
        System.out.print((float)m + " " + (float)d);
    }

}

PTA OOP2 T2

7-2 奇數求和分數 10 作者蔡軻單位南昌航空大學

計算一個數列中所有奇數的和，

輸入格式:

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

輸出格式:

輸入數列中所有奇數之和，例如：25，

輸入樣例:

在這里給出一組輸入，例如：

1 2 3 4 5 6 7 8 9 0

輸出樣例:

在這里給出相應的輸出，例如：

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int a[]={0,0,0,0,0,0,0,0,0,0};
        int i=0;
        int sum=0;
        for(i=0;i<10;i++){
            a[i] = in.nextInt();
            if(a[i]%2 != 0){
               sum += a[i]; 
            }
        }
        System.out.print(sum);
    }

}

PTA OOP2 T3

7-3 房產稅費計算2022 分數 12 作者蔡軻單位南昌航空大學

房屋交易在日常生活中非常常見的事情，房屋交易時要額外支付各種稅費，按2022年房產交易新政策的規定買房人應繳納稅費包括：

1、契稅：首次購房評估額90平（含）內1%、90平-144平（含）內1.5%，超過144平或非首次3%，買方繳納，

2、印花稅：房款的0.05%，

3、交易費：3元/平方米，

4、測繪費：1.36元/平方米，

5、權屬登記費及取證費：一般情況是在200元內，

輸入格式:

四個資料，以空格分隔：
1、第幾次購房（整數）
2、房款（整數/單位萬元）
3、評估價（整數/單位萬元）
4、房屋面積（浮點數/單位平方米），
例如：1 100 100 90，

輸出格式:

契稅、印花稅、交易費、測繪費（以元為單位），以空格分隔，例如：10000.0 500.0 270.0 122.4

輸入樣例:

在這里給出一組輸入，例如：

1 100 100 90

輸出樣例:

在這里給出相應的輸出，例如：

10000.0 500.0 270.0 122.4

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int GouFang = in.nextInt();
        int FangKuan = in.nextInt();
        int PingGuJia = in.nextInt();
        double MianJi = in.nextDouble();
        double QiShui = 0;
        double YinHua = 0;
        double JiaoYi = 0;
        double CeHui = 0;
        if(GouFang==1){
            if(MianJi > 144){
                QiShui = FangKuan*0.03*10000;
            }
            else if(MianJi > 90){
                QiShui = FangKuan*0.015*10000;
            }
            else if(MianJi > 0){
                QiShui = FangKuan*0.01*10000;
            }
        }
        else{
            QiShui = FangKuan*0.03*10000;
        }
        YinHua = FangKuan * 0.0005 * 10000;
        JiaoYi = MianJi * 3;
        CeHui = MianJi * 1.36;
        System.out.print((float)QiShui+" "+(float)YinHua+" "+(float)JiaoYi+" "+(float)CeHui);
    }

}

PTA OOP2 T4

7-4 游戲角色選擇分數 14 作者蔡軻單位南昌航空大學

一款網游中包括4個種族：人類、精靈、獸人、暗精靈，每個種族包含三種角色：戰士、法師、射手，玩家新建人物時需要選擇種族和角色，請撰寫角色選擇程式，

輸入格式:

兩個整數：游戲種族、角色的選項，以空格分隔，例如：1 2，
種族選項設定為：1、人類 2、精靈 3、獸人 4、暗精靈
角色選項設定為：1、戰士 2、法師 3、射手

輸出格式:

所選擇的種族、角色的名稱，以空格分隔，例如：人類法師
若輸入數值超出選項范圍，輸出“Wrong Format”

輸入樣例1:

在這里給出一組輸入，例如：

1 2

輸出樣例1:

在這里給出相應的輸出，例如：

人類 法師

輸入樣例2:

在這里給出一組輸入，例如：

1 6

輸出樣例2:

在這里給出相應的輸出，例如：

Wrong Format

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        int zz = in.nextInt();
        int js = in.nextInt();
        if((zz<1)||(zz>4)||(js<1)||(js>3)){
            System.out.print("Wrong Format");
        }
        else if(zz==1&&js==1){
            System.out.print("人類" + " " + "戰士");
        }
        else if(zz==1&&js==2){
            System.out.print("人類" + " " + "法師");
        }
        else if(zz==1&&js==3){
            System.out.print("人類" + " " + "射手");
        }
        else if(zz==2&&js==1){
            System.out.print("精靈" + " " + "戰士");
        }
        else if(zz==2&&js==2){
            System.out.print("精靈" + " " + "法師");
        }
        else if(zz==2&&js==3){
            System.out.print("精靈" + " " + "射手");
        }
        else if(zz==3&&js==1){
            System.out.print("獸人" + " " + "戰士");
        }
        else if(zz==3&&js==2){
            System.out.print("獸人" + " " + "法師");
        }
        else if(zz==3&&js==3){
            System.out.print("獸人" + " " + "射手");
        }
        else if(zz==4&&js==1){
            System.out.print("暗精靈" + " " + "戰士");
        }
        else if(zz==4&&js==2){
            System.out.print("暗精靈" + " " + "法師");
        }
        else if(zz==4&&js==3){
            System.out.print("暗精靈" + " " + "射手");
        }
        
    }

}

PTA OOP2 T5

7-5 學號識別分數 10 作者蔡軻單位南昌航空大學

學校的學號由8位數字組成，前兩位是入學年份（省略了20）；第3、4位是學院編號，01代表材料學院，02代表機械學院，03代表外語學院，20代表軟體學院；第5、6位是學院內部班級編號，最后兩位是班級內部學號，如：18011103，入學年份是2018年，材料學院，11班，03號

輸入格式:

8位數字組成的學號，例如：18011103
注意：輸入學號不是8位或者學院編號不是01、02、03、20其中之一，屬于非法輸入

輸出格式:

學號每一項的完整說明，例如：
入學年份：2018年
學院：材料學院
班級：11
學號：03

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

輸入樣例:

在這里給出一組輸入，例如：

18011103

輸出樣例:

在這里給出相應的輸出，例如：

入學年份：2018年
學院：材料學院
班級：11
學號：03

輸入樣例1:

在這里給出一組輸入，例如：

輸出樣例1:

在這里給出相應的輸出，例如：

Wrong Format

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String num;
        String nianfen;
        String xueyuan;
        String banji;
        String xuehao;
        num = in.next();
        
        if(num.length() != 8){
            System.out.print("Wrong Format");
            return;
        }
        
        nianfen = num.substring(0,2);
        xueyuan = num.substring(2,4);
        banji = num.substring(4,6);
        xuehao = num.substring(6,8);
        
        if(xueyuan.equalsIgnoreCase("01")) {
            xueyuan = "材料學院";
        }
        else if(xueyuan.equalsIgnoreCase("02")) {
            xueyuan = "機械學院";
        }
        else if(xueyuan.equalsIgnoreCase("03")) {
            xueyuan = "外語學院";
        }
        else if(xueyuan.equalsIgnoreCase("20")) {
            xueyuan = "軟體學院";
        }
        else {
            System.out.print("Wrong Format");
            return;
        }
        
        System.out.println("入學年份：20"+nianfen+"年");
        System.out.println("學院："+xueyuan);
        System.out.println("班級："+banji);
        System.out.print("學號："+xuehao);
    }

}

PTA OOP2 T6

7-6 巴比倫法求平方根近似值分數 10 作者蔡軻單位南昌航空大學

巴比倫法求n的近似值可以用以下公式：
nextGuess = (lastGuess+n/lastGuess)/2
程式初始運行時lastGuess可賦予一個最初的猜測值，當由公式求得的nextGuess和lastGuess相差較大時，把nextGuess的值賦給lastGuess，繼續以上程序，直至nextGuess和lastGuess幾乎相同，此時lastGuess或者nextGuess就是平方根的近似值，
本題要求：nextGuess和lastGuess的差值小于0.00001時認為兩者幾乎相同

輸入格式:

1、兩個浮點數，以空格分隔，第一個是n，第二個是lastGuess最初的猜測值，例如：2 1，
2、若輸入的兩個數中包含負數或者lastGuess初始輸入為0，認定為非法輸入

輸出格式:

1、輸出n的平方根近似值：lastGuess，例如：1.4142157
2、非法輸入時輸出："Wrong Format"

輸入樣例:

在這里給出一組輸入，例如：

2 1

輸出樣例:

在這里給出相應的輸出，例如：

1.4142157

輸入樣例1:

在這里給出一組輸入1，例如：

2 -1

輸出樣例:

在這里給出相應的輸出，例如：

Wrong Format

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        float n = in.nextFloat();
        float lastGuess = in.nextFloat();
        if(n<0||lastGuess<=0){
            System.out.print("Wrong Format");
            return;
        }
        float next=(lastGuess+n/lastGuess)/2;
        while(Math.abs(next-lastGuess)>=0.00001){ 
            lastGuess=next;
            next=(lastGuess+n/lastGuess)/2;
        }
    System.out.print((float)lastGuess);
    }

}

PTA OOP2 T7

7-7 二進制數值提取分數 10 作者蔡軻單位南昌航空大學

在一個字串中提取出其中的二進制數值序列，，

輸入格式:

一個由0、1構成的序列，以-1為結束符，非0、1字符視為正常輸入，但忽略不計，未包含結束符的序列視為非法輸入，例如：abc00aj014421-1

輸出格式:

將輸入的序列去掉非0、1字符以及結尾符的資料內容，
注：結束符-1之后的0\1字符忽略不計，
例如：00011，

輸入樣例:

在這里給出一組輸入，例如：

abc00aj014421-1

輸出樣例:

在這里給出相應的輸出，例如：

輸入樣例1:

在這里給出一組輸入，例如：

a0571-1k001y

輸出樣例1:

在這里給出相應的輸出，例如：

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String ejz = "";
        int i = 0;
        for(i=0;i<str.length();i++){
            if(str.charAt(i)=='0'||str.charAt(i)=='1')
                {ejz += str.charAt(i);}
            else if(str.charAt(i)=='-' && str.charAt(i+1)=='1')
                {System.out.print(ejz);
                return;}
        }
        System.out.print("Wrong Format");
    }

}

PTA OOP2 T8

7-8 判斷三角形型別分數 15 作者段喜龍單位南昌航空大學

輸入三角形三條邊，判斷該三角形為什么型別的三角形，

輸入格式:

在一行中輸入三角形的三條邊的值（實型數），可以用一個或多個空格或回車分隔，其中三條邊的取值范圍均為[1,200]，

輸出格式:

（1）如果輸入資料非法，則輸出“Wrong Format”；
（2）如果輸入資料合法，但三條邊不能構成三角形，則輸出“Not a triangle”；
（3）如果輸入資料合法且能夠成等邊三角形，則輸出“Equilateral triangle”；
（3）如果輸入資料合法且能夠成等腰直角三角形，則輸出“Isosceles right-angled triangle”；
（5）如果輸入資料合法且能夠成等腰三角形，則輸出“Isosceles triangle”；
（6）如果輸入資料合法且能夠成直角三角形，則輸出“Right-angled triangle”；
（7）如果輸入資料合法且能夠成一般三角形，則輸出“General triangle”，

輸入樣例1:

在這里給出一組輸入，例如：

50 50 50.0

輸出樣例1:

在這里給出相應的輸出，例如：

Equilateral triangle

輸入樣例2:

在這里給出一組輸入，例如：

60.2 60.2 80.56

輸出樣例2:

在這里給出相應的輸出，例如：

Isosceles triangle

輸入樣例3:

在這里給出一組輸入，例如：

0.5 20.5 80

輸出樣例3:

在這里給出相應的輸出，例如：

Wrong Format

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        double a = in.nextDouble();
        double b = in.nextDouble();
        double c = in.nextDouble();
        if(a<1||a>200||b<1||b>200||c<1||c>200){
            System.out.println("Wrong Format");
        }
        else if(a+b<=c||a+c<=b||b+c<=a){
            System.out.println("Not a triangle");
        }
        else if(a==b&&a==c&&b==c){
            System.out.println("Equilateral triangle");
        }
        else if((a==b)&&(a*a+b*b-c*c<0.1)){
            System.out.println("Isosceles right-angled triangle");
        }
        else if((a==c)&&(a*a+c*c-b*b<0.1)){
            System.out.println("Isosceles right-angled triangle");
        }
        else if((c==b)&&(c*c+b*b-a*a<0.1)){
            System.out.println("Isosceles right-angled triangle");
        }
        else if(a==b||a==c||b==c){
            System.out.println("Isosceles triangle");
        }
        else if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(c*c+b*b==a*a)){
            System.out.println("Right-angled triangle");
        }
        else{
            System.out.println("General triangle");
        }
    }

}

PTA OOP2 T9

7-9 求下一天分數 14 作者段喜龍單位南昌航空大學

輸入年月日的值（均為整型數），輸出該日期的下一天，其中：年份的合法取值范圍為[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) ; //求輸入日期的下一天

輸入格式:

在一行內輸入年月日的值，均為整型數，可以用一到多個空格或回車分隔，

輸出格式:

當輸入資料非法及輸入日期不存在時，輸出“Wrong Format”；
當輸入日期合法，輸出下一天，格式如下：Next date is:年-月-日

輸入樣例1:

在這里給出一組輸入，例如：

2020 3 10

輸出樣例1:

在這里給出相應的輸出，例如：

Next date is:2020-3-11

輸入樣例2:

在這里給出一組輸入，例如：

2025 2 10

輸出樣例2:

在這里給出相應的輸出，例如：

Wrong Format

代碼長度限制 3 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int year=in.nextInt();
        int month=in.nextInt();
        int day=in.nextInt();
        boolean flag=checkInputValidity(year,month,day);
        if(!flag){
            System.out.println("Wrong Format");
            return;
        }
        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 false;
        }
        int[] isLeap={31,29,31,30,31,30,31,31,30,31,30,31};
        int[] notLeap={31,28,31,30,31,30,31,31,30,31,30,31};
        if(isLeapYear(year) ){
            if(day>isLeap[month-1]||day<1)
                return false;
        }
        else{
            if(day>notLeap[month-1]||day<1)
                return false;
        }
        return true;
    
    }//判斷輸入日期是否合法，回傳布林值
    
    public static void nextDate(int year,int month,int day){
        boolean flag=isLeapYear(year);
        int[] isLeap={31,29,31,30,31,30,31,31,30,31,30,31};
        int[] notLeap={31,28,31,30,31,30,31,31,30,31,30,31};
        if(flag){
            if(month==12&&day==31){
                if(year==2020){
                    System.out.println("Wrong Format");
                }
                else if(year!=2020){
                    System.out.println("Next date is:"+(year+1)+"-1-1");
                }
            }
            else if(month!=12 && day==isLeap[month-1]){
                System.out.println("Next date is:"+year+"-"+(month+1)+"-1");
            }
            else{
                System.out.println("Next date is:"+year+"-"+month+"-"+(day+1));
            }
        }
        else{
            if(month==12&&day==31){
                if(year==2020){
                    System.out.println("Wrong Format");
                }
                else if(year!=2020){
                    System.out.println("Next date is:"+(year+1)+"-1-1");
                }
            }
            else if(month!=12 && day==notLeap[month-1]){
                System.out.println("Next date is:"+year+"-"+(month+1)+"-1");
            }
            else{
                System.out.println("Next date is:"+year+"-"+month+"-"+(day+1));
            }
        }//求輸入日期的下一天
        
    }

}

第二次作業：

　　這次在吸取了第一次作業的經驗之后，對java更加了解，便更加輕松的完成了這一次的pta作業，同時也拿到了滿分，雖然覺得第二次作業比第一次更加簡單，但是第二次作業的邏輯思維更強，特別是最后兩題，判斷三角形型別以及求下一天兩道題目十分注重細節，這再一次讓我意識到，細節與邏輯真的是太重要啦!!!同時，這次的提交總次數只有上次的三分之一不到，也可以看做一種進步吧嘿嘿，同時還是有很多可以改進的地方的，如駝峰形式的變數名稱，我很多都是用的中文拼音寫的，這個習慣很不好，以后要改正才行，

第三次作業

PTA OOP3 T1

7-1 創建圓形類分數 6 作者段喜龍單位南昌航空大學

撰寫一個圓形類Circle，一個私有實型屬性半徑，要求寫出帶引數構造方法、無參構造方法、屬性的getter、setter方法以及求面積、輸出資料等方法，具體格式見輸入、輸出樣例，

輸入格式:

在一行內輸入一個實型數作為圓的半徑（半徑數值要求不能為負值）

輸出格式:

如果半徑輸入非法，則直接輸出Wrong Format
如果輸入半徑合法，則輸出如下兩行資料

The circle's radius is:圓的半徑值

The circle's area is:圓的面積值

要求輸出資料均保留2位小數，PI的取值使用Math.PI，

輸入樣例:

在這里給出一組輸入，例如：

-5

輸出樣例:

在這里給出相應的輸出，例如：

Wrong Format

輸入樣例:

在這里給出一組輸入，例如：

2.5

輸出樣例:

在這里給出相應的輸出，例如：

The circle's radius is:2.50
The circle's area is:19.63

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        double radius = in.nextDouble();
         if (radius < 0.0){
             System.out.print("Wrong Format");
         }
        else{
            Circle circle = new Circle();
            circle.setRadius(radius);
            System.out.println(String.format("The circle's radius is:%.2f",radius));
            System.out.print(String.format("The circle's area is:%.2f",circle.getArea()));
        }
    }

}

class Circle {

    private double radius;
    
    public void setrRadius(double radius){
        this.radius = radius;
    }
    
    public double getRadius(){
        return radius;
    }
    
    public double getArea(){
        return Math.PI*radius*radius;
    }

}

PTA OOP3 T2

7-2 創建賬戶類Account 分數 16 作者段老師單位南昌航空大學

設計一個名稱為Account的類，具體包括：

id：賬號，私有屬性，整型，默認值為0；
balance：余額，私有屬性，實型，默認值為0；
annualInterestRate：當前利率，私有屬性，實型，默認值為0，假設所有帳戶均有相同的利率；
dateCreated：賬戶開戶時間，私有屬性，LocalDate型別，默認為2020年7月31日；
一個能創建默認賬戶的無參構造方法；
一個能創建帶特定id和初始余額的賬戶的構造方法；
id、balance、annualInterstRate的getter及setter方法；
dateCreated的getter方法；
一個名為getMonthlyInterestRate()的方法回傳月利率（月利率計算公式：余額*(年利率/1200）)；
一個名為withDraw的方法從賬戶提取特定數額，當提取數額大于余額或為負數系統回傳WithDraw Amount Wrong提示；
一個名為deposit的方法向賬戶存盤特定數額，當存盤數額大于20000元或為負數系統回傳Deposit Amount Wrong提示，

撰寫一個測驗程式：

創建一個賬戶，其賬戶id、余額及利率分別有鍵盤輸入，賬戶開戶時間取系統當前時間；
輸入取錢金額，系統進行取錢操作，如果取錢金額有誤，則輸出提示資訊后系統繼續運行；
輸入存錢金額，系統進行存錢操作，如果存錢金額有誤，則輸出提示資訊后系統繼續運行；
系統輸出，以如下格式分別輸出該賬戶余額、月利息以及開戶日期（輸出實型數均保留兩位小數）

輸入格式:

在一行內分別輸入賬戶id、初始余額、當前利率、提取金額、存盤金額，資料間采用一個或多個空格分隔，

輸出格式:

共分三行輸出，分別為約、計算的月利息以及開戶日期，格式如下：

```
`The Account'balance:余額`
```
The Monthly interest:月利息
```
`The Account'dateCreated:年-月-日`
```

輸入樣例1:

在這里給出一組輸入，例如：

1122 20000 0.045 800 600

輸出樣例1:

在這里給出相應的輸出，例如：

The Account'balance:19800.00
The Monthly interest:0.74
The Account'dateCreated:2020-07-31

輸入樣例2:

在這里給出一組輸入，例如：

1122 20000 0.045 8000 30000

輸出樣例2:

在這里給出相應的輸出，例如：

Deposit Amount Wrong
The Account'balance:12000.00
The Monthly interest:0.45
The Account'dateCreated:2020-07-31

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Date;
import java.util.Scanner;

public class Main {

     public static void main(String[] args) {
            // TODO Auto-generated method stub
            Scanner in=new Scanner(System.in);
            int zhid=in.nextInt();
            double csye=in.nextDouble();
            double dqll=in.nextDouble();
            double tqje=in.nextDouble();
            double ccje=in.nextDouble();
            
            Account account = new Account(zhid,csye);
            account.setAnnualInterstRate(dqll);
            account.withDraw(tqje);
            account.Deposit(ccje);
            
            System.out.printf("The Account'balance:%.2f\n",account.getBalance());
            System.out.printf("The Monthly interest:%.2f\n",account.getMonthlyInterestRate());
            System.out.println("The Account'dateCreated:2020-07-31");
        }

}

class Account {
    //id：賬號，私有屬性，整型，默認值為0；
    private int id = 0;
    //balance：余額，私有屬性，實型，默認值為0；
    private double balance = 0;
    //annualInterestRate：當前利率，私有屬性，實型，默認值為0，假設所有帳戶均有相同的利率；
    private double annualInterestRate = 0;
    //dateCreated：賬戶開戶時間，私有屬性，LocalDate型別，默認為2020年7月31日；
    private Date dateCreated;
    
    //一個能創建默認賬戶的無參構造方法；
    public Account(){
        dateCreated =new Date();
    }
    
    //一個能創建帶特定id和初始余額的賬戶的構造方法；
    public Account(int id, double balance) {
        this.id = id;
        this.balance = balance;
        Date dataCreated = new Date();
    }
    
    //id的getter{
    public int getId(){
        return id;
    }
    
    //id的setter
    public void setId(){
        this.id = id;
    }
    
    //balance的getter
    public double getBalance(){
        return balance;
    }
    
    //balance的setter
    public void setBalance(){
        this.balance = balance;
    }
    
    //annualInterstRate的getter
    public double getAnnualInterstRate(){
        return annualInterestRate;
    }
    
    //balance的setter
    public void setAnnualInterstRate(double tqje){
        this.annualInterestRate = tqje;
    }
    
    //dateCreated的getter方法；
    public Date getDateCreated(){
        return dateCreated;
    }
    
    //一個名為getMonthlyInterestRate()的方法回傳月利率（月利率計算公式：余額*(年利率/1200）)；
    public double getMonthlyInterestRate(){
        return balance * (annualInterestRate / 1200);
    }
    
    //一個名為withDraw的方法從賬戶提取特定數額，當提取數額大于余額或為負數系統回傳WithDraw Amount Wrong提示；
    public void withDraw(double qqje){
        if(qqje>balance||balance<0||qqje<0){
            System.out.println("WithDraw Amount Wrong");
        }
        else{
            balance-=qqje;
        }
    }
    
    //一個名為deposit的方法向賬戶存盤特定數額，當存盤數額大于20000元或為負數系統回傳Deposit Amount Wrong提示，
    public void Deposit(double ccje){
        if(ccje>20000||ccje<0){
            System.out.println("Deposit Amount Wrong");
            ccje=0;
            balance=balance-ccje;
        }
        balance+=ccje;
    }
}

PTA OOP3 T3

7-3 定義日期類分數 34 作者段喜龍單位南昌航空大學

定義一個類Date，包含三個私有屬性年（year）、月（month）、日（day），均為整型數，其中：年份的合法取值范圍為[1900,2000] ，月份合法取值范圍為[1,12] ,日期合法取值范圍為[1,31] ，
注意：不允許使用Java中和日期相關的類和方法，否則按0分處理，

要求：Date類結構如下圖所示：

類圖.jpg

輸入格式:

在一行內輸入年月日的值，均為整型數，可以用一到多個空格或回車分隔，

輸出格式:

當輸入資料非法及輸入日期不存在時，輸出“Date Format is Wrong”；
當輸入日期合法，輸出下一天，格式如下：Next day is:年-月-日

輸入樣例1:

在這里給出一組輸入，例如：

1912 12 25

輸出樣例1:

在這里給出相應的輸出，例如：

Next day is:1912-12-26

輸入樣例2:

在這里給出一組輸入，例如：

2001 2 30

輸出樣例2:

在這里給出相應的輸出，例如：

Date Format is Wrong

代碼長度限制 16 KB 時間限制 400 ms 記憶體限制 64 MB

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        int year = in.nextInt();
        int month = in.nextInt();
        int day = in.nextInt();
        int[] mon_maxnum = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31};
        Date date = new Date();
        date.Date(year,month,day);
        date.getNextDate();
    }

}

class Date{
    //包含三個私有屬性年（year）、月（month）、日（day），均為整型數;
    private int year = 0;
    private int month = 0;
    private int day = 0;
    int[] mon_maxnum = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31};
    
    public void Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    public int getYear(){
        return this.year;
    }
    
    public void setYear(int year){
        this.year = year;
    }
    
    public int getMonth(){
        return this.month;
    }
    
    public void setMonth(int month){
        this.month = month;
    }
    
    public int getDay(){
        return this.day;
    }
    
    public void setDay(int day){
        this.day = day;
        return;
    }
    
    public boolean isLeapYear(int year){
       if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){
            return true;
        }
        else{
            return false;
        }
    }
    
    public boolean chekInputValidity(){
        if(isLeapYear(year)){
            mon_maxnum[2] = 29;
        }
        if(year >= 1900 && year <= 2000 && month>=1 && month<=12 && day>=1 && day <= mon_maxnum[month]){
            return true;
        }
        else{
            return false;
        }
    }
    
    public void getNextDate(){
        if(isLeapYear(year)){
            mon_maxnum[2] = 29;
        }
        else{
            mon_maxnum[2] = 28;
        }
        if(day < mon_maxnum[month]){
            day++;
        }
        else if(day == 31 && month == 12){
            day = 1;
            month = 1;
            year++;
        }
        else if(day == mon_maxnum[month] && month < 12){
            day = 1;
            month++;
        }
       if(chekInputValidity()) {
           System.out.println("Next day is:" + year + "-" +month + "-" + day);
       }
       else {
           System.out.println("Date Format is Wrong");
            System.exit(0);
       }
    }

}

設計與分析：

　　這個函式我按照題目設計了兩個類，一個Main,一個Date，Date累分為10個函式，前面幾個都很簡單，比較重要的是getNextDate()；類圖如下：

類圖.jpg

這題相比下一道題還是更簡單一點的，雖然結構和下一道題的大同小異，但是還是在難度上差了很多很多，

采坑心得：

　　這道題我并沒有得到滿分，相反，有兩個測驗點沒有通過，扣了4分，最后只有30分，看到大家都有34分，我只有30分，真的好羨慕，但是我真的想不出我哪里寫錯了，那里沒有考慮周全，還是有一點點難過的，希望下次可以用嚴謹的思維模式，得到滿分！加油！

改進建議：

　　下次思考的時候，應該全面思考，不然很容易會像這一次一樣，總是找不出哪兩個測驗點沒有過，這真是好大一個的問題，下次會避免的！

PTA OOP3 T4

7-4 日期類設計分數 44 作者段喜龍單位南昌航空大學

參考題目3和日期相關的程式，設計一個類DateUtil，該類有三個私有屬性year、month、day（均為整型數），其中，year∈[1820,2020] ,month∈[1,12] ,day∈[1,31] , 除了創建該類的構造方法、屬性的getter及setter方法外，需要撰寫如下方法：

public boolean checkInputValidity();//檢測輸入的年、月、日是否合法
public boolean isLeapYear(int year);//判斷year是否為閏年
public DateUtil getNextNDays(int n);//取得year-month-day的下n天日期
public DateUtil getPreviousNDays(int n);//取得year-month-day的前n天日期
public boolean compareDates(DateUtil date);//比較當前日期與date的大小（先后）
public boolean equalTwoDates(DateUtil date);//判斷兩個日期是否相等
public int getDaysofDates(DateUtil date);//求當前日期與date之間相差的天數
public String showDate();//以“year-month-day”格式回傳日期值

應用程式共測驗三個功能：

求下n天
求前n天
求兩個日期相差的天數

注意：嚴禁使用Java中提供的任何與日期相關的類與方法，并提交完整原始碼，包括主類及方法（已提供，不需修改）

程式主方法如下：

import java.util.Scanner;

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

        int choice = input.nextInt();

        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            m = input.nextInt();

            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() + 
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }        
    }
}

輸入格式:

有三種輸入方式（以輸入的第一個數字劃分[1,3]）：

1 year month day n //測驗輸入日期的下n天
2 year month day n //測驗輸入日期的前n天
3 year1 month1 day1 year2 month2 day2 //測驗兩個日期之間相差的天數

輸出格式:

當輸入有誤時，輸出格式如下：
Wrong Format
當第一個數字為1且輸入均有效，輸出格式如下：
```
year1-month1-day1 next n days is:year2-month2-day2
```
當第一個數字為2且輸入均有效，輸出格式如下：
```
year1-month1-day1 previous n days is:year2-month2-day2
```

當第一個數字為3且輸入均有效，輸出格式如下：

The days between year1-month1-day1 and year2-month2-day2 are:值

輸入樣例1:

在這里給出一組輸入，例如：

3 2014 2 14 2020 6 14

輸出樣例1:

在這里給出相應的輸出，例如：

The days between 2014-2-14 and 2020-6-14 are:2312

輸入樣例2:

在這里給出一組輸入，例如：

2 1834 2 17 7821

輸出樣例2:

在這里給出相應的輸出，例如：

1834-2-17 previous 7821 days is:1812-9-19

輸入樣例3:

在這里給出一組輸入，例如：

1 1999 3 28 6543

輸出樣例3:

在這里給出相應的輸出，例如：

1999-3-28 next 6543 days is:2017-2-24

輸入樣例4:

在這里給出一組輸入，例如：

0 2000 5 12 30

輸出樣例4:

在這里給出相應的輸出，例如：

Wrong Format

代碼長度限制 12 KB 時間限制 10000 ms 記憶體限制 64 MB

import java.util.Scanner;

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

        int choice = input.nextInt();

        if (choice == 1) { // test getNextNDays method
            int m = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            m = input.nextInt();

            if (m < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " next " + m + " days is:");
            System.out.println(date.getNextNDays(m).showDate());
        } else if (choice == 2) { // test getPreviousNDays method
            int n = 0;
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            DateUtil date = new DateUtil(year, month, day);

            if (!date.checkInputValidity()) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            n = input.nextInt();

            if (n < 0) {
                System.out.println("Wrong Format");
                System.exit(0);
            }

            System.out.print(
                    date.getYear() + "-" + date.getMonth() + "-" + date.getDay() + " previous " + n + " days is:");
            System.out.println(date.getPreviousNDays(n).showDate());
        } else if (choice == 3) {    //test getDaysofDates method
            year = Integer.parseInt(input.next());
            month = Integer.parseInt(input.next());
            day = Integer.parseInt(input.next());

            int anotherYear = Integer.parseInt(input.next());
            int anotherMonth = Integer.parseInt(input.next());
            int anotherDay = Integer.parseInt(input.next());

            DateUtil fromDate = new DateUtil(year, month, day);
            DateUtil toDate = new DateUtil(anotherYear, anotherMonth, anotherDay);

            if (fromDate.checkInputValidity() && toDate.checkInputValidity()) {
                System.out.println("The days between " + fromDate.showDate() + 
                        " and " + toDate.showDate() + " are:"
                        + fromDate.getDaysofDates(toDate));
            } else {
                System.out.println("Wrong Format");
                System.exit(0);
            }
        }
        else{
            System.out.println("Wrong Format");
            System.exit(0);
        }        
    }
}
class DateUtil{
    private int year = 1900;
    private int month = 1;
    private int day = 1;
    int[] mon_maxnum = new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31};
    public DateUtil(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public int getYear(){
        return this.year;
    }
    public void setYear(int year){
        this.year = year;
    }
    public int getMonth(){
        return this.month;
    }
    public void setMonth(int month){
        this.month = month;
    }
    public int getDay(){
        return this.day;
    }
    public void setDay(int day){
        this.day = day;
        return;
    }
    //檢測輸入的年、月、日是否合法
    public boolean checkInputValidity(){
        if(isLeapYear(year)){
                mon_maxnum[2] = 29;
            }
            if(year >= 1820 && year <= 2020 && month>=1 && month<=12 && day>=1 && day <= mon_maxnum[month]){
                return true;
            }
            else{
                return false;
            }
        }
        //判斷year是否為閏年
        public boolean isLeapYear(int year){
            if((year % 4 == 0 && year % 100 != 0)||(year % 400 == 0)){
                return true;
            }
            else{
                return false;
            }
        }
        //取得year-month-day的下n天日期
        public DateUtil getNextNDays(int n){
          int i;
          for (i=0;i<n;i++){
              if(isLeapYear(year)) {
                  mon_maxnum[2] = 29;
              }
              else{
                  mon_maxnum[2] = 28;
              }
              //閏年跨月不跨年
              if(isLeapYear(year)&&month!=12&&day==mon_maxnum[month]){
                  month = month+1;
                  day = 1;
              }
              //閏年跨年
              else if(isLeapYear(year)&&month==12&&day==mon_maxnum[month]){
                  year = year + 1;
                  month = 1;
                  day = 1;
              }
              //閏年不跨月
              else if (isLeapYear(year)&&day!=mon_maxnum[month]){
                  day ++;
              }
              //非閏年跨月不跨年
              else if(!isLeapYear(year) && month != 12 && day==mon_maxnum[month]){
                  month = month + 1;
                  day = 1;
              }
              //非閏年跨年
              else if(!isLeapYear(year)&&month==12&&day==mon_maxnum[month]) {
                  year = year+1;
                  month = 1;
                  day = 1;
              }
              //非閏年不跨月
              else if(!isLeapYear(year)&&day!=mon_maxnum[month]){
                  day ++;
              }
        }
        return this;
        }
        
    public DateUtil getPreviousNDays(int n){
         int i;
         for (i=0;i<n;i++){
             if(isLeapYear(year)) {
                 mon_maxnum[2] = 29;
             }else {
                 mon_maxnum[2] = 28;
             }
             if (isLeapYear(year)&&month!=1&&day==1){//閏年退月不退年
                 month -= 1;
                 day = mon_maxnum[month];
             }
             else if (isLeapYear(year)&&month==1&&day==1) {//閏年退年
                 year -= 1;
                 month = 12;
                 day = 31;
             }
             else if (isLeapYear(year)&&day!=1) {//閏年不退月
                 day --;
             }
             else if (!isLeapYear(year)&&month!=1&&day==1) {//非閏年退月不退年
                 month -= 1;
                 day = mon_maxnum[month];
             }
             else if (!isLeapYear(year)&&month==1&&day==1) {//非閏年退年
                 year -= 1;
                 month = 12;
                 day = 31;
             }
             else if (!isLeapYear(year)&&day!=1) {//非閏年不跨月
                 day --;
             }
         }
         return this;
     }
    //比較當前日期與date的大小（先后）
    public boolean compareDates(DateUtil date){
        if(year>date.year){
            return false;
        }
        else if(year<date.year){
            return true;
        }
        else{
            if(month>date.month){
                return false;
            }
            else if(month<date.month){
                return true;
            }
            else{
                if(day>date.day){
                    return false;
                }
                else{
                    return true;
                }
            }
        }
    }
    //判斷兩個日期是否相等
    public boolean equalTwoDates(DateUtil date){
        if(date.year==year&&date.day==day&&date.month==month) {
            return true;
        }
        else{
            return false;
        }
    }
    //求當前日期與date之間相差的天數
    public int getDaysofDates(DateUtil date){
        if(isLeapYear(year)) {
            mon_maxnum[2] = 29;
        }
        else{
            mon_maxnum[2] = 28;
        }
        if(isLeapYear(date.year)) {
            mon_maxnum[2] = 29;
        }
        else{
            mon_maxnum[2] = 28;
        }
        int i;
        int DaysOfYears=0;
        int FirstYearDay=0;
        int LastYearDay=0;
        if(equalTwoDates(date)){
            return DaysOfYears;
        }
        else{
            if(compareDates(date)){
                //前大于后
                if(year==date.year){
                    //同一年
                    FirstYearDay = mon_maxnum[date.month]-date.day;
                    //小月剩余的天數
                        for(i=date.month+1;i<month;i++){
                            LastYearDay += mon_maxnum[date.month];
                        }
                        LastYearDay += day;//整月以及大月當月已走過天數之和
                    }
                    else if(year>date.year){//非同一年
                        for(i = date.year + 1; i < year; i++){//計算相隔的完整年的天數
                            if (isLeapYear(i)){
                                DaysOfYears += 366;
                            }
                            else{
                                DaysOfYears += 365;
                            }
                        }
                        for(i = 1; i < date.month; i++) {
                            FirstYearDay += mon_maxnum[i];//已走過的整月的天數
                        }
                        for(i = 1; i < month; i++){
                            LastYearDay += mon_maxnum[i];//已走過的整月的天數
                        }
                        if (isLeapYear(date.year)){
                            FirstYearDay = 366 - FirstYearDay - date.day;//小年當年剩余的天數
                        }
                        else{
                            FirstYearDay = 365 - FirstYearDay - date.day;
                        }
                        LastYearDay += day;//大年當年已走過的天數
                    }
                }
                else{//后大于前
                    if(year == date.year) {//同一年
                        LastYearDay = mon_maxnum[month] - day;//小月剩余的天數
                        for (i = month + 1; i < date.month; i++){
                            FirstYearDay += mon_maxnum[month];
                        }
                        FirstYearDay += date.day;//整月以及大月當月已走過天數之和
                    } else if (year < date.year) {//非同一年
                        for (i = year + 1; i < date.year; i++) {//計算相隔的完整年的天數
                            if (isLeapYear(i)) {
                                DaysOfYears += 366;
                            }
                            else{
                                DaysOfYears += 365;
                            }
                        }
                        for(i = 1; i < date.month; i++) {
                            FirstYearDay += mon_maxnum[i];//已走過的整月的天數
                        }
                        for(i = 1; i < month; i++) {
                            LastYearDay += mon_maxnum[i];//同上
                        }
                        if (isLeapYear(year)) {
                            LastYearDay = 366 - LastYearDay - day;//小年當年剩余的天數
                        }
                        else{
                            LastYearDay = 365 - LastYearDay - day;
                        }
                        FirstYearDay = date.day + 1;//大年當年已走過的天數
                    }
                }
            }
        int sum = DaysOfYears+FirstYearDay+LastYearDay;
            return sum;
        }
        //以“year-month-day”格式回傳日期值
        public String showDate(){
        return (this.year+"-"+this.month+"-"+this.day);
    }
}

設計與分析：

這題分為兩個類 Date和 Main,如下圖，Date類分為15個函式，其中getNextNDays，getPreviousNDays，getDaysofDates這幾個類我覺得是最難的，前兩個其實差別不大，主要考察的就是縝密的邏輯思維以及細節問題，Main函式已經給出，但是Date函式的構造離不開讀懂Main函式，這道題不僅考察了寫代碼，更考察了讀代碼，這才是一名軟體工程專業學生應該擁有的素養，

采坑心得：

　　這道題目我的得分很低，44分只得到26分，那個答案怎樣輸出都是錯誤的，我個人懷疑是引數傳輸錯誤的問題，但是一直都沒有找出來是哪里出現了錯誤，還是和我代碼能力比較弱有關，亦或是被較多的代碼量嚇傻了，有點不敢去找錯誤的地方，還有就是開始撰寫代碼之前沒有做好充分的準備，沒有認真做好設計就開始了，可能導致了很多潛在的錯誤，這也是我的問題之一，希望下次不會犯了嘿嘿，

改進建議：

　　下次開始寫之前先做好相應的設計，寫出思路，再一步步開始完善代碼，寫的時候注重細節，一絲不茍，面面俱到，才能寫出完美的程式，不要害怕代碼的數量，多看看總會看懂的，人總是要跳出自己的舒適去的，這次就是一個很好的體會，只有跳出自己的舒適區才能進步，才能成長，不能拘泥于盡自己的世界，

第三次作業總結：

記得一開始看到只有四道題目還是很開心的，結果后來寫著寫著才發現事情并不簡單，所以到最后只得了78分，前面兩道題寫起來都很輕松，后面兩道題讓我無能為力，可能是自身知識儲備不足，以及邏輯思維不強，亦或是被較多的代碼量嚇傻了，讓我有點不敢鼓起勇氣面對那道題目，最終也只得了一個較低的分數，看到同學們都得了一百分，其實內心還是很羨慕的，同時也堅定了我要每次把作業做到最好的決心，還是有很大的提升空間的，

總結：

這幾次作業，我對JAVA有了一個初步的了解，已經可以寫出一些基本的程式了！學到的東西有很多，比如說JAVA的基本語法，一些很有用的函式，一些很好用的方法，一些很好用的工具......沒想到一個月的時間就可以不害怕JAVA了，同時也有很多可以提升的地方：比如還要多看看慕課，多做做題目，了解更多函式的用法，了解更多面向物件與面向程序的差別，不能每次都在DDL之前才開始寫PTA，要吸取經驗，將書本上的知識轉化為自己的，記牢，記住，并且學會合理的運用他們，學習一門語言并不簡單，做好一件事情也絕非易事，希望我能付出更多的努力，更多的精力，努力鉆研，沉浸式思考，多做多練，腳踏實地謀發展，努力努力再努力！

建議：我真的真的希望老師不要用全英文的課件了！真的看不是很懂啊,能不能在一些重要的東西旁邊稍微注釋一下中文呀，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/548208.html

標籤：其他

上一篇：odoo 開發入門教程系列-基本視圖

下一篇：Go 語言 new 和 make 關鍵字的區別

南昌航空大學-軟體學院-22206104-段清如-JAVA第一次Blog作業

輸入格式:

輸出格式:

輸入樣例1:6

輸出樣例1:實際利率=8.47%

輸入樣例2:-1

輸出樣例2:error

輸入格式:

輸出格式:

輸入樣例0:

輸出樣例0:

輸入樣例1:

輸出樣例1:

輸入格式:

輸出格式:

輸入樣例1:

輸出樣例1:

輸入樣例2:

輸出樣例2:

輸入格式:

輸出格式:

輸入樣例1:

輸出樣例1:

輸入樣例2:

輸出樣例2:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例1:

輸出樣例1:

輸入樣例2:

輸出樣例2:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:YES

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

Input Format:

Output Format:

Sample Input:

Sample Output:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例:

輸出樣例:

輸入格式:

輸出格式:

輸入樣例1:

輸出樣例1:

輸入樣例2:

輸出樣例2:

輸入格式:

輸出格式:

輸入樣例:

輸入樣例1:`6`

輸出樣例1:`實際利率=8.47%`

輸入樣例2:`-1`

輸出樣例2:`error`

輸出樣例:`YES`