PAT乙級21到40題練習代碼全紀錄

• • 廢話完了開正題（21到40題，沒標注就是測試點全通過）
  • • 1021 個位數統計
    • 1022 D進制的A+B
    • 1023 組個最小數
    • 1024 科學計數法
    • 1025 反轉鏈表（測試點5運行超時）
    • 1026 程序運行時間
    • 1027 打印沙漏
    • 1028 人口普查（測試點4運行超時）
    • 1029 舊鍵盤
    • 1030 完美數列（測試點4運行超時）
    • 1031 查驗身份證
    • 1032 挖掘機技術哪家強（測試點3運行超時）
    • 1033 舊鍵盤打字
    • 1034 有理數四則運算
    • 1035 插入與歸并
    • 1036 跟奧巴馬一起編程
    • 1037 在霍格沃茲找零錢
    • 1038 統計同成績學生（測試點3運行超時）
    • 1039 到底買不買
    • 1040 有幾個PAT

其實PAT的坑在刷題過程中就會發現，還是有跡可循的。常見的坑點如：輸入樣例的 數據類型及 范圍限制； 特殊輸入的情況，比如0；輸出數據的 格式；“不超過”，“不低于”等字樣表示的 邊界值情況等。最難識別的還是題目的 邏輯盲點，總之題要好好分析再想解決問題的思路，先理解好題目才能不走彎路！

廢話完了開正題（21到40題，沒標注就是測試點全通過）

1021 個位數統計

import java.util.Scanner; public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);String num = sc.nextLine();int[] count = new int[10];for(int i = 0; i < num.length(); i++) {switch(num.charAt(i)) {case '0': count[0]++; continue;case '1': count[1]++; continue;case '2': count[2]++; continue;case '3': count[3]++; continue;case '4': count[4]++; continue;case '5': count[5]++; continue;case '6': count[6]++; continue;case '7': count[7]++; continue;case '8': count[8]++; continue;case '9': count[9]++; continue;}}for(int i = 0; i < 10; i++) {if(count[i]!=0) {System.out.println(i+":"+count[i]);}}} }

1022 D進制的A+B

注意結果為0的情況哦！

import java.util.Scanner; public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int A = sc.nextInt();int B = sc.nextInt();int D = sc.nextInt();int dec = A + B;StringBuilder numD = new StringBuilder("");if(dec == 0){numD.append("0");}else{while(dec > 0) {numD.append(dec % D);dec = dec / D;}}System.out.println(numD.reverse().toString());} }

1023 組個最小數

唯一要注意的就是尋找開頭數字的條件：數字不為0，計數不為0，并且是計數不為0的數字中最小的數字。剩下的按照有小到大排列即可。

import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] temp = br.readLine().trim().split("\\s+");int[] count = new int[10];int firstDigit = 0;boolean minNotZero = true;for (int i = 0; i < 10; i++) {count[i] = Integer.valueOf(temp[i]);if (i != 0 && minNotZero == true && count[i] != 0) { // 找到非0的最小數字并將對應的計數減1firstDigit = i;count[i]--;minNotZero = false;}}StringBuilder str = new StringBuilder(String.valueOf(firstDigit));for (int i = 0; i < 10; i++) {for (int j = 0; j < count[i]; j++)str.append(String.valueOf(i));}System.out.println(str);} }

1024 科學計數法

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] input = br.readLine().trim().split("E|\\.");char sign1 = input[0].charAt(0); // sign1是整數部分的正負號char sign2 = input[2].charAt(0); // sign2是指數部分的正負號StringBuilder result = new StringBuilder(input[0].charAt(1)+input[1]); // result最終得到輸出結果，首先加入小數點左側的一位數字[1-9]，再加入小數點右側的數字串String[] temp = input[2].split("\\+|\\-"); int exp = Integer.parseInt(temp[1]); // exp存儲指數部分的數字if (sign2 == '-') {for (int i = 0; i < exp; i++)result.insert(0, '0');result.insert(1, '.');} else {int pointMove = exp - input[1].length();if (pointMove >= 0) { // pointMove大于等于0則小數部分為0，即結果為整數，增加0即可for (int i = 0; i < pointMove; i++)result.append('0');}else { // pointMove小于0則挪動小數點，并插入小數點，即結果為浮點數result.insert((exp + 1), '.');}}if (sign1 == '-')result.insert(0, '-');System.out.println(result);} }

1025 反轉鏈表（測試點5運行超時）

本題最大坑點在有可能無法完全遍歷鏈表，如果出現了-1就要提前結束，用-1之前的進行反轉排序并輸出。另外輸出格式要格外注意。測試點5用Java過不了。

import java.io.InputStreamReader; import java.util.ArrayList; import java.io.BufferedReader; public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] str = br.readLine().trim().split("\\s+");int firstNode = Integer.valueOf(str[0]);int n = Integer.parseInt(str[1]);int k = Integer.parseInt(str[2]);Node[] nodes = new Node[100000];while (n-- > 0) {String[] temp = br.readLine().trim().split("\\s+");nodes[Integer.valueOf(temp[0])] = new Node(temp[0], Integer.valueOf(temp[1]), Integer.valueOf(temp[2]));}int address = firstNode;ArrayList<Integer> record = new ArrayList<>();while (address != -1) { // -1之前的記錄下來record.add(address);address = nodes[address].nextNode;}int count = 0;while (record.size() >= (count + 1) * k) // 每k個反轉一次，分別為0到k-1，k到2k-1……reverse(record, count++ * k, count * k - 1);for (int i = 0; i < record.size()-1; i++)System.out.println(nodes[record.get(i)].address+" "+nodes[record.get(i)].value + " "+nodes[record.get(i+1)].address);System.out.println(nodes[record.get(record.size()-1)].address+" "+nodes[record.get(record.size()-1)].value + " -1");}public static void reverse(ArrayList<Integer> record, int start, int end) {while (start < end) {int temp = record.get(start); // swaprecord.set(start++, record.get(end));record.set(end--, temp);}} }class Node {String address; // 便于輸出int value;int nextNode;public Node() {}public Node(String address, int value, int nextNode) {this.address = address;this.value = value;this.nextNode = nextNode;} }

1026 程序運行時間

import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {// 輸入在一行中順序給出 2 個整數 C1 和 C2。注意兩次獲得的時鐘打點數肯定不相同，即 C1 < C2BufferedReader br = new BufferedReader(new InputStreamReader(System.in));final int CLK_TCK = 100;String[] str = br.readLine().trim().split("\\s+");double C1 = Double.parseDouble(str[0]);double C2 = Double.parseDouble(str[1]);int gap = (int) Math.round((C2 - C1) / CLK_TCK);int[] time = new int[3];time[2] = gap % 60; // 秒time[1] = ((gap - time[0]) / 60) % 60; // 分time[0] = ((gap - time[0]) / 60 - time[1]) / 60; // 時for(int i = 0; i < 3; i++) {if(time[i] < 10)System.out.print("0"); // 不夠兩位就要用0補位System.out.print(time[i]);if(i < 2)System.out.print(":");}} }

1027 打印沙漏

import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] str = br.readLine().trim().split("\\s+");int n = Integer.parseInt(str[0]);char c = str[1].charAt(0);int count = 1, index = 1;while (count <= n) {count += 2 * (2 * index + 1);index++;}if (n != 0)count -= 2 * (2 * (index - 1) + 1); // 會多算一次elsecount = 0;int row = (index - 2) * 2; // row指沙漏打印0到row行/* 打印上半部分，直到一行內的符號為1個，共打印 row/2+1行 */for (int i = 0; i <= row / 2; i++) { for (int j = 0; j < i; j++) // 思路：第一行0個并且遞增System.out.print(" ");for (int k = 1; k <= 2 * (row / 2 - i) + 1; k++) // 思路：第row/2行打印1個System.out.print(c);System.out.println();}/* 打印下半部分，共打印 row/2行，打印行數為row/2+1到row行 */for (int i = row / 2 + 1; i <= row; i++) { for (int j = 0; j < row - i; j++) // 思路：第row行打印0個并遞減System.out.print(" ");for (int k = 1; k <= 2 * (i - row / 2) + 1; k++) // 思路：第row/2+1行打印3個System.out.print(c);System.out.println();}System.out.println(n - count);} }

1028 人口普查（測試點4運行超時）

坑！一道只要用java，就基本無法避免第4個測試點超時運行的題。之前題目無論怎樣，只要改變寫法總還是能找到可以全通過的方法，這一道真的艱難。但是以下還是提供些能通過0-3測試點的寫法（們）。
注意：要通過第三個測試點必須注意輸入0時，輸出為0。

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Calendar; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int N = Integer.parseInt(br.readLine());ArrayList<Citizen> list = new ArrayList<>();for (int i = 0; i < N; i++) {String[] in = br.readLine().trim().split("\\s|/");Citizen c = new Citizen(in[0], in[1], in[2], in[3]);if (c.isLegel()) // 符合輸入要求才加入數組列表list.add(c);}int old = 0, young = 0; // 用來記錄最老和最年輕的序號if (list.size() > 0) {Calendar oldest = list.get(0).birthday;Calendar youngest = list.get(0).birthday;for (int i = 0; i < list.size(); i++) {if (list.get(i).birthday.before(oldest)) { // 找出最老oldest = list.get(i).birthday;old = i;}if (list.get(i).birthday.after(youngest)) { // 找出最年輕youngest = list.get(i).birthday;young = i;}}System.out.println(list.size() + " " + list.get(old).name + " " + list.get(young).name);}elseSystem.out.println("0");} }class Citizen { // 用Comparable大概會更慢吧……我就不嘗試了String name;Calendar birthday = Calendar.getInstance();public Citizen() {}public Citizen(String str, String y, String m, String d) {name = str;birthday.set(Integer.parseInt(y), Integer.parseInt(m) - 1, Integer.parseInt(d));// 這里要注意Calendar的set方法中月份從0開始，因而輸入時要比實際月份-1}public boolean isLegel() {boolean flag = false;Calendar now = Calendar.getInstance();now.clear();now.set(2014, 8, 7);Calendar earliest = Calendar.getInstance();earliest.clear();earliest.set(1814, 8, 6);if (birthday.after(earliest) && birthday.before(now))flag = true;return flag;} }

一次不行再試一次，于是努力地往便捷地寫，把日期比較簡化成比較數字大小。

import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int N = Integer.valueOf(br.readLine());String theElder = null, theYoung = null ; // 記錄最長者和最年輕者的名字int oldest = 0, youngest = 0; // 記錄最長者和最年輕者的生日int count = 0; // 記錄符合要求的個數for (int i = 0; i < N; i++) {String[] temp = br.readLine().trim().split("\\s|/");int bday = Integer.valueOf(temp[1] + temp[2] + temp[3]);if (bday >= 18140906 && bday <= 20140906) {count++;if (count == 1) {oldest = bday;youngest = bday;theElder = temp[0];theYoung = temp[0];} else {if (bday < oldest) {oldest = bday;theElder = temp[0];}if (bday > youngest) {youngest = bday;theYoung = temp[0];}}}}if (count > 0)System.out.println(count + " " + theElder + " " + theYoung);elseSystem.out.println("0");} }

這個地步還不行我就放棄了……一搜發現根本找不到能全通過的java寫法，C++也不能用String而是strcmp方法（總之費勁啊），附上其他語言的滿分解答。
C C++ Python

1029 舊鍵盤

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String input = br.readLine().toUpperCase(); // 鍵盤輸入String str1 = br.readLine().toUpperCase(); // 實際輸入ArrayList<Character> output = new ArrayList<>(); // 將實際輸入轉化成數組列表以使用contains方法char[] temp = str1.toCharArray();for (int i = 0; i < str1.length(); i++)output.add(temp[i]);ArrayList<Character> brokenKey = new ArrayList<>(); // 壞鍵for (int i = 0; i < input.length(); i++) {Character ch = input.charAt(i);if (output.contains(ch) == false && brokenKey.contains(ch) == false) // 未能實際輸入并且還尚未記錄brokenKey.add(ch);}for(int i = 0; i < brokenKey.size(); i++)System.out.print(brokenKey.get(i));} }

1030 完美數列（測試點4運行超時）

最后一個測試點考察的依舊是數據類型，輸入數據均小于10⁹，但是在乘法過程中就可能出現10¹⁸，但是int型取值為-2³¹~2³¹-1，大概是十位，也就是說用int可能溢出。倒數第二個測試點java寫運行超時難以避免。

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] str1 = br.readLine().trim().split("\\s+");int N = Integer.parseInt(str1[0]);int p = Integer.parseInt(str1[1]);String[] str2 = br.readLine().trim().split("\\s+");ArrayList<Long> perfect = new ArrayList<>(); // 避免溢出用Long類for (int i = 0; i < N; i++) {perfect.add(Long.parseLong(str2[i]));}Collections.sort(perfect); // 升序排序int start = 0, count = 0;int optimal = 0; // 存儲最佳結果while (true) {count = 0;for(int i = start; i < N; i++) {if(perfect.get(i) <= perfect.get(start) * p)count++;elsebreak;}if (count > optimal)optimal = count;start++;if (optimal >= N - start) // 如果剩余長度不大于最佳結果，則當前結果必為最佳break;}System.out.println(optimal);} }

附上C++滿分答案：C++

1031 查驗身份證

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int N = Integer.valueOf(br.readLine()); // N個待查驗的身份證號ArrayList<String> list = new ArrayList<>(); // 錯誤的身份證號for (int i = 0; i < N; i++) {String in = br.readLine().trim();if (isLegel(in) != in.charAt(17)) // 檢查最后一個校驗碼是否正確list.add(in);}if(list.size()==0)System.out.println("All passed");else {for(int i = 0; i < list.size(); i++)System.out.println(list.get(i));}}private static char isLegel(String in) {int total = (in.charAt(0)-'0')*7;total += (in.charAt(1)-'0')*9;total += (in.charAt(2)-'0')*10;total += (in.charAt(3)-'0')*5;total += (in.charAt(4)-'0')*8;total += (in.charAt(5)-'0')*4;total += (in.charAt(6)-'0')*2;total += (in.charAt(7)-'0')*1;total += (in.charAt(8)-'0')*6;total += (in.charAt(9)-'0')*3;total += (in.charAt(10)-'0')*7;total += (in.charAt(11)-'0')*9;total += (in.charAt(12)-'0')*10;total += (in.charAt(13)-'0')*5;total += (in.charAt(14)-'0')*8;total += (in.charAt(15)-'0')*4;total += (in.charAt(16)-'0')*2;char M = 0;switch(total%11) {case 0: M = '1'; break;case 1: M = '0'; break;case 2: M = 'X'; break;case 3: M = '9'; break;case 4: M = '8'; break;case 5: M = '7'; break;case 6: M = '6'; break;case 7: M = '5'; break;case 8: M = '4'; break;case 9: M = '3'; break;case 10: M = '2';}return M;}}

1032 挖掘機技術哪家強（測試點3運行超時）

坑！（又）一道只要用java，就基本無法避免第3個測試點超時運行的題，以下提供些能通過0到2測試點的方式。思路很明顯，有key有value用HashMap<>。

import java.util.HashMap; import java.io.IOException; import java.io.BufferedReader; import java.io.InputStreamReader; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int N = Integer.parseInt(br.readLine().trim());HashMap<Integer, Integer> teamMap = new HashMap<>();int teamID = 0, points = 0; // 輸入的隊伍，分數Integer max = 0, index = 0; // 當前最高分，最高分所在隊伍for(int i = 0; i < N; i++) {String[] str = br.readLine().trim().split("\\s+");teamID = Integer.parseInt(str[0]);points = Integer.parseInt(str[1]);if(teamMap.containsKey(teamID)) { // 輸入的該隊伍是否記錄過teamMap.put(teamID, teamMap.get(teamID) + points);}else {teamMap.put(teamID, points);}if(teamMap.get(teamID)>max) { // 找最高分max = teamMap.get(teamID);index = teamID;}}System.out.println(index+" "+max); } }

累……累了，附上滿分其他語言答案：C/C++

1033 舊鍵盤打字

弄清楚壞鍵對需要打印的字符串的影響：

如果 ‘+’（此處指大寫鎖定鍵）壞了，大寫字母無法打印；

壞鍵中字母以大寫表示，則字符串中此字母無論大小寫都無法打印；

其他壞鍵只要在字符串中出現就無法打印。

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.ArrayList; import java.io.IOException;public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String str0 = br.readLine().trim();String input = br.readLine().trim();ArrayList<Character> brokenKey = new ArrayList<>(); // 將第一行輸入的壞鍵轉換成數字列表，以便使用contains方法for (int i = 0; i < str0.length(); i++)brokenKey.add(str0.charAt(i));StringBuilder output = new StringBuilder(""); // 初始化為空字符串for (int i = 0; i < input.length(); i++) {Character ch = input.charAt(i);if (brokenKey.contains('+') && Character.isUpperCase(ch)) // 如果大寫鎖定鍵壞了而且當前需要打印的字母為大寫，跳過continue;Character ch2 = Character.isLetter(ch) ? Character.toUpperCase(ch) : ch;if (brokenKey.contains(ch2)) // 如果壞鍵和當前需要打印的一致，跳過continue;output.append(ch);}System.out.println(output.toString());} }

1034 有理數四則運算

哈……數據類型是永遠的坑。如果是后兩個測試點不通過而前兩個通過了，問題一般就是出在了int型上。因為在計算過程中（尤其是乘法）比較容易超出int范圍。我想到的解決方法有二：

改用long，gcd自己寫，可以用輾轉相除法化簡

改用BigInteger類，調用gcd方法化簡

另外，在轉換成標準格式的分數過程中，還需要注意：

雖然題目有說僅在分子前有負號，但計算中也可能出現分子分母都為負的情況（除法）

若除法分母為 0，輸出Inf

import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.math.BigInteger; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] str = br.readLine().trim().split("\\s+|/");BigInteger a1 = new BigInteger(str[0]);BigInteger b1 = new BigInteger(str[1]);BigInteger a2 = new BigInteger(str[2]);BigInteger b2 = new BigInteger(str[3]);String str0 = simplify(a1, b1);String str1 = simplify(a2, b2);System.out.println(str0 + " + " + str1 + " = " + simplify(a1.multiply(b2).add(a2.multiply(b1)), b1.multiply(b2)));System.out.println(str0 + " - " + str1 + " = " + simplify(a1.multiply(b2).add(a2.multiply(b1).negate()), b1.multiply(b2)));System.out.println(str0 + " * " + str1 + " = " + simplify(a1.multiply(a2), b1.multiply(b2)));System.out.print(str0 + " / " + str1 + " = ");if (str1 == "0")System.out.println("Inf");elseSystem.out.println(simplify(a1.multiply(b2), b1.multiply(a2)));}private static BigInteger[] divideGCD(BigInteger a, BigInteger b) {BigInteger gcd = a.gcd(b);a = a.divide(gcd);b = b.divide(gcd);BigInteger[] result = {a,b};return result;}private static String simplify(BigInteger a, BigInteger b) {StringBuilder simp = new StringBuilder("");if (a.equals(BigInteger.ZERO)) // 分子為0直接返回0return "0";boolean isOdd = a.multiply(b).compareTo(BigInteger.ZERO) < 0 ? true : false;if (isOdd)simp.append("(-");a = a.abs(); // 將兩個數字取絕對值b = b.abs();while(a.gcd(b).compareTo(BigInteger.ONE)>0) { // 將兩個數字除以所有非1公約數BigInteger[] temp = divideGCD(a,b);a = temp[0];b = temp[1];}BigInteger[] part = a.divideAndRemainder(b);if (part[0].compareTo(BigInteger.ONE)>=0) { // 取整數部分simp.append(part[0]);a = part[1];if (a.compareTo(BigInteger.ZERO)>0)simp.append(" ");}if (a.compareTo(BigInteger.ZERO)>0) // 取分數部分simp.append(a + "/" + b);if (isOdd)simp.append(")");return simp.toString();} }

1035 插入與歸并

我看到許多人都是直接用sort寫的，這里就當作是訓練自己的基礎算法了，自己寫了完整的非遞歸歸并排序和僅一步的插入排序。思路如下：

先判定插入還是歸并，根據題目要求，只可能為二者之一，于是發現插入排序的判斷條件為：從結束升序的數字開始，接下來的數列中數字均與原數列中對應位置數字相同

10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0
1 2 3 5 7 8 9 4 6 0 // 樣例輸出結果

判斷為插入排序：以當前數組match為對象，從標記結束升序的位置，將此位置對應數字向前插入至其正確順序的位置

判斷為歸并排序：以原始數組ori為對象，從步長為2開始，逐次將步長*2。將步長內子數組分為左右兩組，按照大小進行歸并，并將超出原始數組的部分略去

另外，過程中通過測試可以發現，測試點0、2、4是插入排序； 測試點1、3、5、6是歸并排序，并且5、6與 （n % len != 0）的情況有關，并且測試點5的步長至少大于8

import java.io.InputStreamReader; import java.util.Arrays; import java.io.BufferedReader; public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(br.readLine().trim());String[] str1 = br.readLine().trim().split("\\s+");String[] str2 = br.readLine().trim().split("\\s+");int[] ori = new int[n]; // 原始數組int[] match = new int[n]; // 將要進行比對的數組int pos = 0; // 結束升序的位置，0表示還沒找到boolean isInsertion = true;for (int i = 0; i < n; i++) {ori[i] = Integer.parseInt(str1[i]);match[i] = Integer.parseInt(str2[i]);if (pos == 0 && i > 0 && match[i] < match[i - 1]) // 標記升序結束pos = i;if (pos != 0 && ori[i] != match[i]) // 結束升序后，比對數組是否與原數組相同，不同則不是插入排序isInsertion = false;}if (isInsertion) {System.out.println("Insertion Sort");ori = match;insertionSort(ori, 0, pos);} else {System.out.println("Merge Sort");int len = 1;boolean eureka = false;while (eureka == false) {eureka = Arrays.equals(ori, match); // 變化后數組與比對數組相同則本輪結束后退出循環len *= 2;for (int i = 0; i < n; i += len) { // 共i個步長的子數組mergeSort(ori, i, len);}}}for (int i = 0; i < n - 1; i++) // 打印最終結果System.out.print(ori[i] + " ");System.out.println(ori[n - 1]);}private static void mergeSort(int[] arr, int from, int len) {int to = Math.min(from + len - 1, arr.length - 1); // 結束排序的位置，即右側的終點int mid = from + len / 2; // 一分為二，為右側的開端int current1 = from;int current2 = mid;int current3 = 0; // 臨時數組的序號int[] temp = new int[len];while (current1 <= mid - 1 && current2 <= to) {if (arr[current1] < arr[current2]) {temp[current3++] = arr[current1++];} else {temp[current3++] = arr[current2++];}}while (current1 <= mid - 1 && current1 < arr.length) // 要小心這里也可能溢出temp[current3++] = arr[current1++];while (current2 <= to)temp[current3++] = arr[current2++];int k = 0;while (from < arr.length && k < temp.length)arr[from++] = temp[k++];}private static void insertionSort(int[] arr, int start, int pos) {for (int i = pos - 1; i >= start; i--) {if (arr[pos] < arr[i]) {int temp = arr[pos];arr[pos] = arr[i];arr[i] = temp;pos = i;}}} }

1036 跟奧巴馬一起編程

import java.io.BufferedReader; import java.io.InputStreamReader; public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] str1 = br.readLine().trim().split("\\s+");int n = Integer.parseInt(str1[0]); // 邊長char ch = str1[1].charAt(0);int wid = (int) Math.round((double) n / 2); // 注意四舍五入for (int j = 0; j < wid; j++) {if (j == 0 || j == wid - 1) {for (int i = 0; i < n; i++)System.out.print(ch);System.out.println();} else {System.out.print(ch);for (int i = 0; i < n - 2; i++)System.out.print(" ");System.out.println(ch);}}}}

1037 在霍格沃茲找零錢

import java.io.BufferedReader; import java.io.InputStreamReader; public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] str1 = br.readLine().trim().split("\\.|\\s");long[] gallon = new long[3];long[] sickle = new long[3];long[] knut = new long[3];long[] total = new long[2]; // 算總價，以knut為單位int j = 0;for (int index = 0; index < 2; index++) {gallon[index] = Long.parseLong(str1[j++]);sickle[index] = Long.parseLong(str1[j++]);knut[index] = Long.parseLong(str1[j++]);total[index] = gallon[index]*17*29 + sickle[index]*29 + knut[index];}long change = total[1] - total[0]; // 算差價，以knut為單位if(change < 0) {System.out.print("-");change = Math.abs(change);}knut[2] = change % 29;sickle[2] = ((change - knut[2]) / 29) % 17;gallon[2] = (change - knut[2] - sickle[2] * 29)/(17*29);System.out.println(gallon[2]+"."+sickle[2]+"."+knut[2]);} }

1038 統計同成績學生（測試點3運行超時）

可以用hashmap，很慢就對了

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.HashMap;public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(br.readLine().trim());String[] str1 = br.readLine().trim().split("\\s+");String[] str2 = br.readLine().trim().split("\\s+");int num = Integer.parseInt(str2[0]); // 待計數的分數個數HashMap<Integer, Integer> gradeMap = new HashMap<>();for (int i = 1; i <= num; i++) {gradeMap.put(Integer.parseInt(str2[i]), 0);}int grade = 0;for (int i = 0; i < n; i++) {grade = Integer.parseInt(str1[i]);gradeMap.computeIfPresent(grade, (k, v) -> v + 1); // key值出現就value+1}for(int i = 1; i <= num; i++) {System.out.print(gradeMap.get(Integer.parseInt(str2[i])));if(i != num)System.out.print(" ");}} }

純粹用數組快了不少，但最后一個測試點還是過不了

import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.HashMap;public class Main {public static void main(String[] args) throws Exception {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(br.readLine().trim());String[] str1 = br.readLine().trim().split("\\s+");String[] str2 = br.readLine().trim().split("\\s+");int k = Integer.parseInt(str2[0]); // 待計數的分數個數int[] match = new int[k];for (int i = 1; i <= k; i++) {match[i - 1] = Integer.parseInt(str2[i]);}int[] count = new int[k];int grade = 0;for (int i = 0; i < n; i++) {grade = Integer.parseInt(str1[i]);for (int j = 0; j < k; j++) {if (grade == match[j]) {count[j]++;break;}}}for(int i = 0; i < k-1; i++)System.out.print(count[i]+" ");System.out.println(count[k-1]);} }

1039 到底買不買

hashmap只能通過最后一個測試點，太慢了

import java.io.InputStreamReader; import java.util.HashMap; import java.util.Iterator; import java.io.BufferedReader; import java.io.IOException;public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String a = br.readLine().trim();String b = br.readLine().trim();HashMap<Character, Integer> beads = new HashMap<>(); // 建立珠子和個數間的映射Character ch;for (int i = 0; i < b.length(); i++) {ch = b.charAt(i);if (beads.containsKey(ch)) {beads.compute(ch, (k, v) -> v + 1); // 找到已存在的，就將映射個數+1} else {beads.put(ch, 1); // 找到第一次出現的就初始化}}for (int i = 0; i < a.length(); i++) {ch = a.charAt(i);if (beads.containsKey(ch)) {if (beads.get(ch) > 0) {beads.compute(ch, (k, v) -> v - 1); // 找到一個對應的珠子，個數-1}}}Iterator<Character> it = beads.keySet().iterator();int count = 0; // 統計剩余珠子個數while (it.hasNext()) {ch = it.next();count += beads.get(ch);}/* 打印結果 */if (count == 0)System.out.println("Yes " + (a.length() - b.length()));elseSystem.out.println("No " + count);} }

于是又想到了數組列表，終于全部通過了。

import java.io.InputStreamReader; import java.util.ArrayList; import java.io.BufferedReader; import java.io.IOException;public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String a = br.readLine().trim();String str = br.readLine().trim();ArrayList<Character> b = new ArrayList<>();for (int i = 0; i < str.length(); i++) {b.add(str.charAt(i));}/* 在a串中找到一個珠子，就將b串中的最后一個對應珠子移除 */Character ch;int pos;for (int i = 0; i < a.length(); i++) {ch = a.charAt(i);if (b.contains(ch)) {pos = b.lastIndexOf(ch);b.remove(pos);}if (b.size() == 0) // 如果已經全部找到了就停止break;}/* 打印結果 */int size = b.size();if (size == 0)System.out.println("Yes " + (a.length() - str.length()));elseSystem.out.println("No " + size);} }

1040 有幾個PAT

本題需要花費一定時間理解題意所示的計算方式，比較好的方式是自己先寫出來一個比較復雜的字串，如：ATAPPTATPATTAPT。分析思路如下：

我們不難發現，第一個P之前出現的字母是沒有意義的，因此排除在外，將PPTATPATTAPT作為有效字串；

P后出現的第一個A前，如果有其他字母無須計算在內，即PTAT僅包含1個PAT；

一個A后有多少個T，即可以此A組成多少個AT；

一個P后有多少個AT，就相當于每個A組成AT數之和；

為便于計算，由后向前看。

import java.io.InputStreamReader; import java.io.BufferedReader; import java.io.IOException; public class Main {public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String str = br.readLine().trim(); // 長度不超過100000，即在整型范圍內int firstP = str.indexOf('P');String a = str.substring(firstP); // a為有效部分int countA = 0;int countT = 0;long count = 0;int lastT = a.lastIndexOf('T');for (int i = lastT; i >= 0; i--) {if (a.charAt(i) == 'P')count += countA; // 當前P后有多少個ATif (a.charAt(i) == 'A')countA += countT; // 當前A后有多少個T，就可以組成多少個ATif (a.charAt(i) == 'T')countT++;}count = count % 1000000007; System.out.println(count);} }

總結

以上是生活随笔為你收集整理的【Java】PAT乙级真题全记录（二）21到40题的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。