《Java基礎+進階》-浙江大學MOOC

基礎篇：

1.溫度轉換

題目內容：
寫一個將華氏溫度轉換成攝氏溫度的程序，轉換的公式是：
°F = (9/5)*°C + 32
其中C表示攝氏溫度，F表示華氏溫度。
程序的輸入是一個整數，表示華氏溫度。輸出對應的攝氏溫度，也是一個整數。
提示，爲了把計算結果的浮點數轉換成整數，需要使用下面的表達式：
(int)x;
其中x是要轉換的那個浮點數。

注意：除了題目要求的輸出，不能輸出任何其他內容，比如輸入時的提示，輸出時的說明等等都不能。這道題目要求轉換後的數字，程序就只能輸出這個數字，除此之外任何內容都不能輸出。

輸入格式:
一個整數。

輸出格式：
一個整數。

輸入樣例：
100

輸出樣例：
37

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class TempChange{
	
	public static void main(String[] args){
		int f;
		double c;
		Scanner in = new Scanner(System.in);
		f = in.nextInt();
		c = (5.0 / 9) * (f - 32);
		System.out.println((int)c);
		in.close();
	}
}

---

2.時間換算

題目內容：
UTC是世界協調時，BJT是北京時間，UTC時間相當於BJT減去8。現在，你的程序要讀入一個整數，表示BJT的時和分。整數的個位和十位表示分，百位和千位表示小時。如果小時小於10，則沒有千位部分；如果小時是0，則沒有百位部分；如果分小於10分，需要保留十位上的0。如1124表示11點24分，而905表示9點5分，36表示0點36分，7表示0點7分。
有效的輸入範圍是0到2359，即你的程序不可能從測試服務器讀到0到2359以外的輸入數據。
你的程序要輸出這個時間對應的UTC時間，輸出的格式和輸入的相同，即輸出一個整數，表示UTC的時和分。整數的個位和十位表示分，百位和千位表示小時。如果小時小於10，則沒有千位部分；如果小時是0，則沒有百位部分；如果分小於10分，需要保留十位上的0。
提醒：要小心跨日的換算。

輸入格式:
一個整數，表示BJT的時和分。整數的個位和十位表示分，百位和千位表示小時。如果小時小於10，則沒有千位部分；如果小時是0，則沒有百位部分；如果小時不是0而且分小於10分，需要保留十位上的0。

輸出格式：
一個整數，表示UTC的時和分。整數的個位和十位表示分，百位和千位表示小時。如果小時小於10，則沒有千位部分；如果小時是0，則沒有百位部分；如果小時不是0而且分小於10分，需要保留十位上的0。

輸入樣例：
933

輸出樣例：
133

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;  
  
public class TimeStamp {  
  
	public static void main(String[] args) {  
		Scanner in = new Scanner(System.in);  
		int bjt;  
		int g, s;  
		bjt = in.nextInt();  
		g = bjt % 10;  
		s = bjt % 100 / 10;  
		bjt = bjt / 100;  
		if(bjt < 8){  
			bjt = (bjt + 24 - 8);  
			System.out.print(bjt);  
			System.out.print(s);  
			System.out.println(g);  
		}  
		else if(bjt == 8)  
		{  
			if(s != 0)  
				System.out.print(s);  
			System.out.println(g);  
		}  
		else if(bjt > 8){  
			System.out.print(bjt - 8);  
			System.out.print(s);  
			System.out.println(g);  
		}  
	}    
}

---

3.信號報告

題目內容：
無線電臺的RS制信號報告是由三兩個部分組成的：
R(Readability) 信號可辨度即清晰度.
S(Strength) 信號強度即大小.
其中R位於報告第一位，共分5級，用1—5數字表示.
1—Unreadable
2—Barely readable, occasional words distinguishable
3—Readable with considerable difficulty
4—Readable with practically no difficulty
5—Perfectly readable
報告第二位是S，共分九個級別，用1—9中的一位數字表示
1—Faint signals, barely perceptible
2—Very weak signals
3—Weak signals
4—Fair signals
5—Fairly good signals
6—Good signals
7—Moderately strong signals
8—Strong signals
9—Extremely strong signals
現在，你的程序要讀入一個信號報告的數字，然後輸出對應的含義。如讀到59，則輸出：
Extremely strong signals, perfectly readable.

輸入格式:
一個整數，信號報告。整數的十位部分表示可辨度，個位部分表示強度。輸入的整數範圍是[11,59]內有效的數字，這個範圍外的數字不可能出現在測試數據中。

輸出格式：
一句話，表示這個信號報告的意義。按照題目中的文字，先輸出表示強度的文字，跟上逗號和空格，然後是表示可辨度的文字，跟上句號。注意可辨度的句子的第一個字母是小寫的。注意這裏的標點符號都是英文的。

輸入樣例：
33

輸出樣例：
Weak signals, readable with considerable difficulty.

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class ReadabilityStrength {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int rs = in.nextInt();
		int rs1 = rs / 10;
		int rs2 = rs % 10;
		switch (rs2) {
		case 1:
			System.out.print("Faint signals, barely perceptible");
			break;
		case 2:
			System.out.print("Very weak signals");
			break;
		case 3:
			System.out.print("Weak signals");
			break;
		case 4:
			System.out.print("Fair signals");
			break;
		case 5:
			System.out.print("Fairly good signals");
			break;
		case 6:
			System.out.print("Good signals");
			break;
		case 7:
			System.out.print("Moderately strong signals");
			break;
		case 8:
			System.out.print("Strong signals");
			break;
		case 9:
			System.out.print("Extremely strong signals");
			break;
		}
		System.out.print(", ");
		switch(rs1) {
		case 1:
			System.out.print("unreadable");
			break;
		case 2:
			System.out.print("barely readable, occasional words distinguishable");
			break;
		case 3:
			System.out.print("readable with considerable difficulty");
			break;
		case 4:
			System.out.print("readable with practically no difficulty");
			break;
		case 5:
			System.out.print("perfectly readable");
			break;
		}
		System.out.print(".");
		in.close();
	}
}

---

4.奇偶個數

題目內容：
你的程序要讀入一系列正整數數據，輸入-1表示輸入結束，-1本身不是輸入的數據。程序輸出讀到的數據中的奇數和偶數的個數。

輸入格式:
一系列正整數，整數的範圍是（0,100000）。如果輸入-1則表示輸入結束。

輸出格式：
兩個整數，第一個整數表示讀入數據中的奇數的個數，第二個整數表示讀入數據中的偶數的個數。兩個整數之間以空格分隔。

輸入樣例：
9 3 4 2 5 7 －1

輸出樣例：
4 2

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int num;
		int odd = 0;
		int even = 0;
		do {
			num = in.nextInt();
			if(num != -1) {
				if(num % 2 == 0)
					even++;
				else
					odd++;
			}
		}while(num != -1);
		System.out.println(odd + " " + even);
		in.close();
	}
}

---

5.數字特徵值

題目內容：
對數字求特徵值是常用的編碼算法，奇偶特徵是一種簡單的特徵值。對於一個整數，從個位開始對每一位數字編號，個位是1號，十位是2號，以此類推。這個整數在第n位上的數字記作x，如果x和n的奇偶性相同，則記下一個1，否則記下一個0。按照整數的順序把對應位的表示奇偶性的0和1都記錄下來，就形成了一個二進制數字。比如，對於342315，這個二進制數字就是001101。

這裏的計算可以用下面的表格來表示：
| 數字 | 3 | 4 | 2 | 3 | 1 | 5 |
| ------ |-------------| -----|
| 數位 | 6 | 5 | 4 | 3 | 2 | 1 |
| 數字奇偶 | 奇 | 偶 | 偶 | 奇 | 奇 | 奇 |
| 數位奇偶 | 偶 | 奇 | 偶 | 奇 | 偶 | 奇 |
| 奇偶一致 | 0 | 0 | 1 | 1 | 0 | 1 |
| 二進制位值 | 32 | 16 | 8 | 4 | 2 | 1 |

按照二進制位值將1的位的位值加起來就得到了結果13。

你的程序要讀入一個非負整數，整數的範圍是[0,100000]，然後按照上述算法計算出表示奇偶性的那個二進制數字，輸出它對應的十進制值。

提示：將整數從右向左分解，數位每次加1，而二進制值每次乘2。

輸入格式:
一個非負整數，整數的範圍是[0,1000000]。

輸出格式：
一個整數，表示計算結果。

輸入樣例：
342315

輸出樣例：
13
時間限制：500ms
內存限制：32000kb

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 num = in.nextInt();
		int lastnum,sum = 0,count = 0;
		do {
			count++;
			lastnum = num % 10;
			if((lastnum + count) % 2 == 0) {
				sum += Math.pow(2,count - 1);
			}
			num /= 10;
		}while(num > 0);
		System.out.println(sum);
		in.close();
	}
}

---

6.素數和

題目內容：
我們認爲2是第一個素數，3是第二個素數，5是第三個素數，依次類推。
現在，給定兩個整數n和m，$0<n<=m<=200\quad$你的程序要計算第n個素數到第m個素數之間所有的素數的和，包括第n個素數和第m個素數。

注意，是第n個素數到第m個素數之間的所有的素數，並不是n和m之間的所有的素數。

輸入格式:
兩個整數，第一個表示n，第二個表示m。

輸出格式：
一個整數，表示第n個素數到第m個素數之間所有的素數的和，包括第n個素數和第m個素數。

輸入樣例：
2 4

輸出樣例：
15

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		int sum = 0;
		int count = 0;
		int x = 2;
		
		do {
			boolean isPrime = true;
			for(int i = 2; i < x; i++) {
				if(x % i == 0) {
					isPrime = false;
					break;
				}
			}
			if(isPrime) {
				count++;
				if(count >= n && count <= m) {
					sum += x;
				}
			}
			x++;
		}while(0 < count && count <= 200);
		
		System.out.println(sum);
		in.close();	
	}
}

---

7.念整數

題目內容：
你的程序要讀入一個整數，範圍是[-100000,100000]。然後，用漢語拼音將這個整數的每一位輸出出來。
如輸入1234，則輸出：
yi er san si
注意，每個字的拼音之間有一個空格，但是最後的字後面沒有空格。當遇到負數時，在輸出的開頭加上“fu”，如-2341輸出爲：
fu er san si yi

輸入格式:
一個整數，範圍是[-100000,100000]。

輸出格式：
表示這個整數的每一位數字的漢語拼音，每一位數字的拼音之間以空格分隔，末尾沒有空格。

輸入樣例：
-30

輸出樣例：
fu san ling

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int num = in.nextInt();
		int count = 0;
		
                if(num == 0)
			System.out.print("ling");
	
        	if(num < 0) {
			num = -num;
			System.out.print("fu ");
		}
		
		// 計算數位
		int temp = num;
		for(;temp > 0;) { 
			temp /= 10;
			count++;
		}
		
		// 從高數位打印到低數位
		for(; count > 0; count--) {
			int x = (num / (int)Math.pow(10, count - 1)) % 10;
			switch(x) {
			case 1:
				System.out.print("yi");
				break;
			case 2:
				System.out.print("er");
				break;
			case 3:
				System.out.print("san");
				break;
			case 4:
				System.out.print("si");
				break;
			case 5:
				System.out.print("wu");
				break;
			case 6:
				System.out.print("liu");
				break;
			case 7:
				System.out.print("qi");
				break;
			case 8:
				System.out.print("ba");
				break;
			case 9:
				System.out.print("jiu");
				break;
			case 0:
				System.out.print("ling");
			}
			if(count != 1)  
				System.out.print(" ");    
		}
		in.close();
	}
}

---

8. 多項式加法

題目內容：
一個多項式可以表達爲x的各次冪與係數乘積的和，比如：
2x6+3x5+12x3+6x+20
現在，你的程序要讀入兩個多項式，然後輸出這兩個多項式的和，也就是把對應的冪上的係數相加然後輸出。
程序要處理的冪最大爲100。

輸入格式:
總共要輸入兩個多項式，每個多項式的輸入格式如下：
每行輸入兩個數字，第一個表示冪次，第二個表示該冪次的係數，所有的係數都是整數。第一行一定是最高冪，最後一行一定是0次冪。
注意第一行和最後一行之間不一定按照冪次降低順序排列；如果某個冪次的係數爲0，就不出現在輸入數據中了；0次冪的係數爲0時還是會出現在輸入數據中。

輸出格式：
從最高冪開始依次降到0冪，如：
2x6+3x5+12x3-6x+20
注意其中的x是小寫字母x，而且所有的符號之間都沒有空格，如果某個冪的係數爲0則不需要有那項。

輸入樣例：
6 2
5 3
3 12
1 6
0 20
6 2
5 3
2 12
1 6
0 20

輸出樣例：
4x6+6x5+12x3+12x2+12x+40

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        final int MAX_POWER = 100;
        int[] coefficients = new int[MAX_POWER+1];

        // INPUT
        coefficientPutIn(coefficients);
        
        // OUTPUT
        int count = 0;
        boolean only0 = true;
        for (int i = MAX_POWER; i >= 0; i--){
            // 係數不爲零才輸出
            if (coefficients[i] != 0){
                count++;
                only0 = false;
               
                // 1.係數部分
                // 1.1係數符號：係數大於0且不是第一個數，左邊添“+”號
                if (coefficients[i] > 0){
                    if (count != 1){
                        System.out.print("+");
                    }
                }
                
                // 1.2係數數字：係數爲1或-1，不顯示“1”（除非是常數項）
                if (coefficients[i] != 1 && coefficients[i] != -1){
                    System.out.print(coefficients[i]);
                }
                else if (coefficients[i] == 1)
                {
                    if (i == 0){
                        System.out.print("1");
                    }       
                }
                else if (coefficients[i] == -1){
                    System.out.print("-");
                    if (i == 0){
                        System.out.print("1");
                    }                   
                }

                // 2.x部分
                if (i >= 2){
                    System.out.print("x" + i);
                }
                else if (i == 1){
                    System.out.print("x");
                }
                else if (i == 0);               
            }
        }
        // 所有係數都爲0的情況
        if (only0){
            System.out.print(0);
        }
    }
    
    private static void coefficientPutIn(int[] coefficients) {
        Scanner in = new Scanner(System.in);
        int cnt = 0;
        while(cnt < 2){
            int power = in.nextInt();
            int coefficient = in.nextInt();
            coefficients[power] += coefficient;
            if(power == 0)
                cnt++;
        }
       in.close();
    }
}

---

9.單詞長度

題目內容：
你的程序要讀入一行文本，其中以空格分隔爲若干個單詞，以‘.’結束。你要輸出這行文本中每個單詞的長度。這裏的單詞與語言無關，可以包括各種符號，比如“it’s”算一個單詞，長度爲4。注意，行中可能出現連續的空格。

輸入格式:
輸入在一行中給出一行文本，以‘.’結束，結尾的句號不能計算在最後一個單詞的長度內。

輸出格式：
在一行中輸出這行文本對應的單詞的長度，每個長度之間以空格隔開，行末沒有最後的空格。

輸入樣例：
It’s great to see you here.

輸出樣例：
4 5 2 3 3 4

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		String s = in.nextLine();
    		if(s.equals(".")) {}
    		else {
	    		while(!(s.equals(" "))) {
	    			int space = s.indexOf(' ');
	    			if(space == -1) {
	    				if((s.length()-1) != 0) {
	    					System.out.print(s.length()-1);
	    					break;
	    				}
	    			}
	    			else {
	    				System.out.print(space + " ");
	    				s = s.substring(space+1);
	    				s = s.trim();
	    			}
	    		}
    		}
        in.close();
    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String s = in.next();
		
		if(s.equals(".")) {}
		else {
			while(!s.endsWith(".")) {
				System.out.print(s.length() + " ");
				s = in.next();
			}
		System.out.print(s.length()-1);
		}
		in.close();
	}
}

---

10.GPS數據處理

題目內容：
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的大寫字母的。另外，如果你需要的話，可以用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

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int hour = 0;
		int min = 0;
		int sec = 0;
		String s = "";
		do {
			s = in.nextLine();
			if(s.startsWith("$GPRMC")) {
				int num = 0;
				for(int i = 0; i < s.length(); i++) {
					if(s.indexOf("$") < i && i < s.indexOf("*")) {
						num ^= s.charAt(i);
					}
				}

				String a = s.substring(s.indexOf(",")+1);
				String b = a.substring(a.indexOf(",")+1,a.indexOf(",")+2); // 狀態：是否定位？
				if(Integer.toHexString(num).toUpperCase().equals(s.substring(s.indexOf("*")+1)) && b.equals("A")) {
					hour = Integer.parseInt(s.substring(s.indexOf(",")+1,s.indexOf(",")+3))+8;
					min = Integer.parseInt(s.substring(s.indexOf(",")+3,s.indexOf(",")+5));
					sec = Integer.parseInt(s.substring(s.indexOf(",")+5,s.indexOf(",")+7));
					if(hour >= 24 && (min > 0 || sec > 0)) {
						hour -= 24;
					}
				}
			}
		}while(!s.equals("END"));
		
		if(hour < 10) {
			System.out.print(0);
		}
		System.out.print(hour + ":");
		if(min < 10) {
			System.out.print(0);
		}
		System.out.print(min + ":");
		if(sec < 10) {
			System.out.print(0);
		}
		System.out.print(sec);
		in.close();
	}
}

---

11.分解質因數

題目內容：
每個非素數（合數）都可以寫成幾個素數（也可稱爲質數）相乘的形式，這幾個素數就都叫做這個合數的質因數。比如，6可以被分解爲2x3，而24可以被分解爲2x2x2x3。
現在，你的程序要讀入一個[2,100000]範圍內的整數，然後輸出它的質因數分解式；當讀到的就是素數時，輸出它本身。

輸入格式:
一個整數，範圍在[2,100000]內。

輸出格式：
形如：
n=axbxcxd
或
n=n
所有的符號之間都沒有空格，x是小寫字母x。

輸入樣例：
18

輸出樣例：
18=2x3x3

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {
	
    public static String resolvePrime(int num) {  
        // 定義結果字符串緩存對象，用來保存結果字符  
        StringBuffer s = new StringBuffer(num + "=");  
        // 最小素數   
        int i = 2;  
        // 進行輾轉相除法  
        while (i <= num) {  
            if (num % i == 0) {  
                s.append(i + "x");  
                num /= i;  
                i = 2;  
            } 
            else {  
                i++;  
            }  
        }  
        // 去除字符串緩存對象最後的一個x，將結果返回  
        return s.toString().substring(0, s.toString().length() - 1);  
    }  
    
    public static boolean isPrime(int num) {
    		if(num == 2) return true;
    		for(int i = 2; i < num; i++) {
    			if(num % i == 0) return false;
    		}
    		return true;
    }

	public static void main(String[] args) {
	   Scanner in =  new Scanner(System.in);
	   int x = in.nextInt();
	   if(isPrime(x)) 
		   System.out.println(x+"="+x);
	   else 
		   System.out.println(resolvePrime(x));
	   in.close();
	}
}

---

12.完數

題目內容：
一個正整數的因子是所有可以整除它的正整數。而一個數如果恰好等於除它本身外的因子之和，這個數就稱爲完數。例如6=1＋2＋3(6的因子是1,2,3)。
現在，你要寫一個程序，讀入兩個正整數n和m$（1<=n<m<1000）$，輸出[n,m]範圍內所有的完數。

提示：可以寫一個函數來判斷某個數是否是完數。

輸入格式:
兩個正整數，以空格分隔。

輸出格式：
其間所有的完數，以空格分隔，最後一個數字後面沒有空格。如果沒有，則輸出一個空行。

輸入樣例：
1 10

輸出樣例：
6

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {
	public static boolean isPerfect(int num) {
		int sum = 1;
		if(num == 1) return false;
		for(int i = 2; i < num; i++) {
			if(num % i == 0) {
				sum += i;
			}
		}
		if(sum == num) 
			return true;
		return false;
	}

	public static void main(String[] args) {
		Scanner in =  new Scanner(System.in);
		int a = in.nextInt();
		int b = in.nextInt();
		int[] nums = new int[1000];
		int cnt = 0;
		for(int i = a; i <= b; i++) {
			if(isPerfect(i)) {
				nums[cnt++] = i;
			}
		}
		if(cnt == 0) System.out.println();
		else {
			for(int i = 0; i < cnt - 1; i++)
				System.out.print(nums[i] + " ");
			System.out.println(nums[cnt-1]);
		}
		in.close();
	}
}

---

期末考試：二進制的前導的零

題目內容：
計算機內部用二進制來表達所有的值。一個十進制的數字，比如18，在一個32位的計算機內部被表達爲00000000000000000000000000011000。可以看到，從左邊數過來，在第一個1之前，有27個0。我們把這些0稱作前導的零。

現在，你的任務是寫一個程序，輸入一個整數，輸出在32位二進制表達下它前導的零的個數。

輸入格式:
一個整數，在32位的整數可以表達的範圍內。

輸出格式：
一個整數，表達輸入被表達爲一個32位的二進制數時，在第一個1之前的0的數量。

輸入樣例：
256

輸出樣例：
23

思路：用Integer.toBinaryString(number)求出整數的二進制字符串，然後用32-string.length()得到前導零的個數。

import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int wei = 32;
        int number = in.nextInt();
        String result = Integer.toBinaryString(number);
 
        if (number != 0) {
            System.out.println(wei - result.length());
        } else {
            System.out.println(wei);
        }
        in.close();
    }
}

---

進階篇 :

1.分數

題目內容：
設計一個表示分數的類Fraction。這個類用兩個int類型的變量分別表示分子和分母。
這個類的構造函數是：

Fraction(int a, int b)
構造一個a/b的分數。

這個類要提供以下的功能：

double toDouble();
將分數轉換爲double

Fraction plus(Fraction r);
將自己的分數和r的分數相加，產生一個新的Fraction的對象。注意小學四年級學過兩個分數如何相加的哈。

Fraction multiply(Fraction r);
將自己的分數和r的分數相乘，產生一個新的Fraction的對象。

void print();
將自己以“分子/分母”的形式輸出到標準輸出，並帶有回車換行。如果分數是1/1，應該輸出1。當分子大於分母時，不需要提出整數部分，即31/30是一個正確的輸出。

注意，在創建和做完運算後應該化簡分數爲最簡形式。如2/4應該被化簡爲1/2。

你寫的類要和以下的代碼放在一起，並請勿修改這個代碼：

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		Fraction a = new Fraction(in.nextInt(), in.nextInt());
		Fraction b = new Fraction(in.nextInt(),in.nextInt());
		a.print();
		b.print();
		a.plus(b).print();
		a.multiply(b).plus(new Fraction(5,6)).print();
		a.print();
		b.print();
		in.close();
	}

}

注意，你的類的定義應該這樣開始：

class Fraction {

也就是說，在你的類的class前面不要有public。

輸入格式:
程序運行時會得到四個數字，分別構成兩個分數，依次是分子和分母。

輸出格式：
輸出一些算式。這些輸入和輸出都是由Main類的代碼完成的，你的代碼不要做輸入和輸出。

輸入樣例：
2 4 1 3

輸出樣例：
1/2
1/3
5/6
1
1/2
1/3

時間限制：500ms
內存限制：32000kb

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		Fraction a = new Fraction(in.nextInt(), in.nextInt());
		Fraction b = new Fraction(in.nextInt(),in.nextInt());
		a.print();
		b.print();
		a.plus(b).print();
		a.multiply(b).plus(new Fraction(5,6)).print();
		a.print();
		b.print();
		in.close();
	}
}

class Fraction {
	int a, b;
	Fraction(int a, int b) {
		this.a = a;
		this.b = b;
	}
	
	double toDouble() {  
        return  a * 1.0 / b;  
    }  
	
	Fraction plus(Fraction r) {  
        Fraction m = new Fraction(0, 1);  
        m.b = r.b * b;  
        m.a = a * r.b + b * r.a;  
        return m;  
    }  
	
	Fraction multiply(Fraction r) {  
        Fraction m = new Fraction(0, 1);  
        m.b = r.b * b;  
        m.a = a * r.a;  
        return m;  
    } 
	
	void print() {
		int r, x = b;
		int y = a;
		while(y != 0) {
			r = x % y;
			x = y;
			y = r;
		}
		a /= x;
		b /= x;
		
		if(a == b)
			System.out.println(a);
		else
			System.out.println(a + "/" + b);
	}
}