强烈推荐
1009. 说反话 (20)-浙大PAT乙级真题java实现
1009. 说反话 (20)
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。
输入格式：测试输入包含一个测试用例，在一行内给出总长度不超过80的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用1个空格分开，输入保证句子末尾没有多余的空格。
输出格式：每个测试用例的输出占一行，输出倒序后的句子。
输入样例：
Hello World Here I Come
输出样例：输入样例：
Come I Here World Hello
1010. 一元多项式求导 (25)-浙大PAT乙级真题java实现
1010. 一元多项式求导 (25)
设计函数求一元多项式的导数。（注：x^n（n为整数）的一阶导数为n*x^(n-1)。）
输入格式：以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。
输出格式：以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是0，但是表示为“0 0”。
输入样例：
3 4 -5 2 6 1 -2 0
输出样例：
12 3 -10 1 6 0
注意：记得考虑没有输入的情况。以及，输入的只是常数项的情况。这个时候是要输出”0 0″的。
1065.单身狗(25)–PAT乙级真题java实现
输入格式：
输入第一行给出一个正整数N（<=50000），是已知夫妻/伴侣的对数；随后N行，每行给出一对夫妻/伴侣——为方便起见，每人对应一个ID号，为5位数字（从00000到99999），ID间以空格分隔；之后给出一个正整数M（<=10000），为参加派对的总人数；随后一行给出这M位客人的ID，以空格分隔。题目保证无人重婚或脚踩两条船。
输出格式：
首先第一行输出落单客人的总人数；随后第二行按ID递增顺序列出落单的客人。ID间用1个空格分隔，行的首尾不得有多余空格。
输入样例：
3
11111 22222
33333 44444
55555 66666
7
55555 44444 10000 88888 22222 11111 23333
输出样例：
5
10000 23333 44444 55555 88888
分析：
设立数组couples[i] = j表示i的对象是j。一开始先设置为都是-1。设立数组appear表示某人的对象是否来到了派对上。接收数据的时候，对于每一对wife和husband，将couple的husband设置为wife，wife设置为husband，表示他俩是一对。对于每一个需要判断的人，将其存储在guest数组里面，如果它不是单身的（也就是如果它的couple[guest[i]] != -1）那么就将它对象的appear设置为1，表示他对象的对象（也就是他自己）来到了派对。这样所有appear不为1的人，对象是没有来到派对的。
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.Arrays;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()); int couples[] = new int[100000]; int appear[] = new int[100000]; for(int i = 0; i < 100000; i++) { couples[i] = -1; appear[i] = -1; } for(int i = 0; i < N; i++) { String[] s = br.readLine().split(" "); int wife = Integer.parseInt(s[0]); int husband = Integer.parseInt(s[1]); couples[wife] = husband; couples[husband] = wife; } int M = Integer.parseInt(br.readLine()); String[] guest = br.readLine().split(" "); int minus = 0; for(int i = 0; i < M; i++) { int g = Integer.parseInt(guest[i]); if(couples[g] != -1) appear[couples[g]] = 1; if(couples[g]!=-1 && appear[couples[g]]==1 && appear[g]==1){ minus += 2; } } Arrays.sort(guest); boolean flag = false; System.out.println(guest.length - minus); for(int i = 0; i < guest.length;i++) { int g = Integer.parseInt(guest[i]); if(appear[g] != 1) { if(flag) { System.out.print(" " + guest[i]); }else { System.out.print(guest[i]); flag = true; } } } }}1011. A+B和C (15)-浙大PAT乙级真题java实现
1011. A+B和C (15)
给定区间[-2^31, 2^31]内的3个整数A、B和C，请判断A+B是否大于C。
输入格式：
输入第1行给出正整数T(<=10)，是测试用例的个数。随后给出T组测试用例，每组占一行，顺序给出A、B和C。整数间以空格分隔。
输出格式：
对每组测试用例，在一行中输出“Case #X: true”如果A+B>C，否则输出“Case #X: false”，其中X是测试用例的编号（从1开始）。
输入样例：
4
1 2 3
2 3 4
2147483647 0 2147483646
0 -2147483648 -2147483647
输出样例：
Case #1: false
Case #2: true
Case #3: true
Case #4: false
1041. 考试座位号(15)-浙大PAT乙级真题java实现
1041. 考试座位号(15)
每个PAT考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。
输入格式：
输入第一行给出一个正整数N（<=1000），随后N行，每行给出一个考生的信息：“准考证号 试机座位号 考试座位号”。其中准考证号由14位数字组成，座位从1到N编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。考生信息之后，给出一个正整数M（<=N），随后一行中给出M个待查询的试机座位号码，以空格分隔。
输出格式：
对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用1个空格分隔。
输入样例：
4
10120150912233 2 4
10120150912119 4 1
10120150912126 1 3
10120150912002 3 2
2
3 4
输出样例：
10120150912002 2
10120150912119 1
1067. 试密码(20)–PAT乙级真题java实现
输入格式：
输入在第一行给出一个密码（长度不超过20的、不包含空格、Tab、回车的非空字符串）和一个正整数N（<= 10），分别是正确的密码和系统允许尝试的次数。随后每行给出一个以回车结束的非空字符串，是用户尝试输入的密码。输入保证至少有一次尝试。当读到一行只有单个#字符时，输入结束，并且这一行不是用户的输入。
输出格式：
对用户的每个输入，如果是正确的密码且尝试次数不超过N，则在一行中输出“Welcome in”，并结束程序；如果是错误的，则在一行中按格式输出“Wrong password: 用户输入的错误密码”；当错误尝试达到N次时，再输出一行“Account locked”，并结束程序。
输入样例1：
Correct%pw 3
correct%pw
Correct@PW
whatisthepassword!
Correct%pw
#
输出样例1：
Wrong password: correct%pw
Wrong password: Correct@PW
Wrong password: whatisthepassword!
Account locked
输入样例2：
cool@gplt 3
coolman@gplt
coollady@gplt
cool@gplt
try again
#
输出样例2：
Wrong password: coolman@gplt
Wrong password: coollady@gplt
Welcome in
分析：
1.如果已经是”#”了就不要继续下面的判断了，不然可能输出Wrong password: “#”
2.如果密码错误并且达到了尝试的次数，是先输出Wrong password那句紧接着输出Account locked那句
3.Wrong password: 后面有个空格。
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[] s = br.readLine().split(" "); String pwd = s[0]; int times = Integer.parseInt(s[1]); while(times > 0) { String pass = br.readLine(); if(pass.equals(pwd)) { System.out.println("Welcome in"); break; }else if(pass.equals("#")) { break; }else { System.out.println("Wrong password: " + pass); times--; } } if(times <= 0) System.out.println("Account locked"); }}1001. 害死人不偿命的(3n+1)猜想 (15分)-浙大PAT乙级真题java实现
1001. 害死人不偿命的(3n+1)猜想 (15分)
卡拉兹(Callatz)猜想：
对任何一个自然数n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把(3n+1)砍掉一半。这样一直反复砍下去，最后一定在某一步得到n=1。卡拉兹在1950年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证(3n+1)，以至于有人说这是一个阴谋，卡拉兹是在蓄意延缓美国数学界教学与科研的进展……
我们今天的题目不是证明卡拉兹猜想，而是对给定的任一不超过1000的正整数n，简单地数一下，需要多少步（砍几下）才能得到n=1？
输入格式：
每个测试输入包含1个测试用例，即给出自然数n的值。
输出格式：
输出从n计算到1需要的步数。
输入样例
3
输出样例
5
1012. 数字分类 (20)-PAT乙级真题-浙大PAT乙级真题java实现
1012. 数字分类 (20)
给定一系列正整数，请按要求对数字进行分类，并输出以下5个数字：
A1 = 能被5整除的数字中所有偶数的和；
A2 = 将被5除后余1的数字按给出顺序进行交错求和，即计算n1-n2+n3-n4…；
A3 = 被5除后余2的数字的个数；
A4 = 被5除后余3的数字的平均数，精确到小数点后1位；
A5 = 被5除后余4的数字中最大数字。
输入格式：
每个输入包含1个测试用例。每个测试用例先给出一个不超过1000的正整数N，
随后给出N个不超过1000的待分类的正整数。数字间以空格分隔。
输出格式：
对给定的N个正整数，按题目要求计算A1~A5并在一行中顺序输出。
数字间以空格分隔，但行末不得有多余空格。
若其中某一类数字不存在，则在相应位置输出“N”。
输入样例1：
13 1 2 3 4 5 6 7 8 9 10 20 16 18
输出样例1：
30 11 2 9.7 9
输入样例2：
8 1 2 4 5 6 7 9 16
输出样例2：
N 11 2 N 9
1063. 计算谱半径(20)–PAT乙级真题java实现
1063. 计算谱半径(20)–PAT乙级真题java实现
1068. 万绿丛中一点红(20)–PAT乙级真题java实现
输入格式：
输入第一行给出三个正整数，分别是M和N（<= 1000），即图像的分辨率；以及TOL，是所求像素点与相邻点的颜色差阈值，色差超过TOL的点才被考虑。随后N行，每行给出M个像素的颜色值，范围在[0, 224)内。所有同行数字间用空格或TAB分开。
输出格式：
在一行中按照“(x, y): color”的格式输出所求像素点的位置以及颜色值，其中位置x和y分别是该像素在图像矩阵中的列、行编号（从1开始编号）。如果这样的点不唯一，则输出“Not Unique”；如果这样的点不存在，则输出“Not Exist”。
输入样例1：
8 6 200
0 0 0 0 0 0 0 0
65280 65280 65280 16711479 65280 65280 65280 65280
16711479 65280 65280 65280 16711680 65280 65280 65280
65280 65280 65280 65280 65280 65280 165280 165280
65280 65280 16777015 65280 65280 165280 65480 165280
16777215 16777215 16777215 16777215 16777215 16777215 16777215 16777215
输出样例1：
(5, 3): 16711680
输入样例2：
4 5 2
0 0 0 0
0 0 3 0
0 0 0 0
0 5 0 0
0 0 0 0
输出样例2：
Not Unique
输入样例3：
3 3 5
1 2 3
3 4 5
5 6 7
输出样例3：
Not Exist
import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.HashMap;import java.util.Map;public class Main { static int dir[][] = new int[][]{{-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1}, {1, 0}, {1, -1}, {0, -1}}; static int[][] screen = new int[1001][1001]; static int tol; static int n; static int m; public static boolean judge(int i, int j) { for (int k = 0; k < 8; k++) { int tx = i + dir[k][0]; int ty = j + dir[k][1]; if (tx >= 0 && tx < n && ty >= 0 && ty < m && screen[i][j] - screen[tx][ty] >= 0 - tol && screen[i][j] - screen[tx][ty] <= tol) return false; } return true; } public static void main(String[] args) throws IOException{ BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int cnt = 0, x = 0, y = 0; String[] s = br.readLine().split(" "); m = Integer.parseInt(s[0]); n = Integer.parseInt(s[1]); tol = Integer.parseInt(s[2]); Map map = new HashMap<>(); for(int i = 0; i < n; i++) { String[] sp = br.readLine().split("\\s+|\t"); for(int j = 0; j < m; j++) { screen[i][j] = Integer.parseInt(sp[j]); if(map.containsKey(screen[i][j])) map.put(screen[i][j], map.get(screen[i][j]) + 1); else map.put(screen[i][j], 1); } } for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (map.get(screen[i][j]) == 1 && judge(i, j) == true) { cnt++; x = i + 1; y = j + 1; } } } if (cnt == 1) System.out.printf("(%d, %d): %d", y, x, screen[x-1][y-1]); else if (cnt == 0) System.out.printf("Not Exist"); else System.out.printf("Not Unique"); }}