PAT 试题集【JAVA版】

Dear 丶 2022-06-10 11:29 238阅读 0赞

*   *   *  1008 数组元素循环右移问题
         *  1009 说反话
         *  1010 一元多项式求导
         *  1013 数素数
         *  1021 各位数统计
         *  1031 查验身份证
         *  1036 和奥巴马一起编程
         *  1041 考试座位号
         *  1046 划拳
         *  1067 试密码

--------------------

### 1008 数组元素循环右移问题 ###

**Problem:**  
一个数组A中存有N（N>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（M>=0）个位置，即将A中的数据由（A0 A1……AN-1）变换为（AN-M …… AN-1 A0 A1……AN-M-1）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

**Input:**  
每个输入包含一个测试用例，第1行输入N ( 1<=N<=100)、M（M>=0）；第2行输入N个整数，之间用空格分隔。

**Output:**  
在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

**Input Example:**

6 2
    1 2 3 4 5 6

**Output Example:**

5 6 1 2 3 4

**Code:**

import java.util.Scanner;
    
    public class Main { 
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String[] tmp = sc.nextLine().trim().split(" ");
            int N = Integer.parseInt(tmp[0]);
            int t = Integer.parseInt(tmp[1]);
    
            String[] data = sc.nextLine().trim().split(" ");
    
            while (t-- > 0) {
                String s = data[data.length - 1];
                int times = data.length - 1;
                while (times > 0) {
                    data[times] = data[times - 1];
                    times--;
                }
                data[0] = s;
            }
            System.out.println(toString(data));
        }
    
        public static String toString(String[] args) {
            StringBuilder sb = new StringBuilder();
            for (String string : args) {
                sb.append(string + " ");
            }
            return sb.toString().trim();
        }
    }

--------------------

### 1009 说反话 ###

**Problem:**  
给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

**Input:**  
测试输入包含一个测试用例，在一行内给出总长度不超过80的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用1个空格分开，输入保证句子末尾没有多余的空格。

**Output:**  
每个测试用例的输出占一行，输出倒序后的句子。

**Input Example:**

Hello World Here I Come

**Output Example:**

Come I Here World Hello

**Code:**

import java.util.Scanner;
    
    public class Main { 
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String[] tmp = sc.nextLine().trim().split(" ");
    
            System.out.println(toString(tmp));
        }
    
        public static String toString(String[] ss) {
            StringBuilder sb = new StringBuilder();
            for (int i = ss.length - 1; i >= 0; i--) {
                sb.append(ss[i] + " ");
            }
            return sb.toString().trim();
        }
    }

--------------------

### 1010 一元多项式求导 ###

**Problem:**

设计函数求一元多项式的导数。（注：xn（n为整数）的一阶导数为n\*xn-1。）

**Input:**  
以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

**Output:**

以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是0，但是表示为“0 0”。

**Input Example:**

3 4 -5 2 6 1 -2 0

**Output Example:**

12 3 -10 1 6 0

**Code:**

import java.util.Scanner;
    
    public class Main { 
    
        public static void main(String[] args) {
    
            boolean hasPrintBlack = false;
            Scanner sc = new Scanner(System.in);
            while (sc.hasNext()) {
                int ratio = sc.nextInt();
                int index = sc.nextInt();
                if (ratio * index != 0) {
                    if (hasPrintBlack) {
                        System.out.print(" ");
                    } else {
                        hasPrintBlack = true;
                    }
                    System.out.print(ratio * index + " " + (index - 1));
                }
            }
            if (hasPrintBlack == false) {
                System.out.println("0 0");
            }
        }
    }

--------------------

### 1013 数素数 ###

**Problem:**

令Pi表示第i个素数。现任给两个正整数M <= N <= 104，请输出PM到PN的所有素数。

**Input:**

输入在一行中给出M和N，其间以空格分隔。

**Output:**

输出从PM到PN的所有素数，每10个数字占1行，其间以空格分隔，但行末不得有多余空格。

**Input Example:**

5 27

**Output Example:**

11 13 17 19 23 29 31 37 41 43
    47 53 59 61 67 71 73 79 83 89
    97 101 103

**Tip:**

不能单纯使用素数判断的方法，否则会导致超时。

**Code:**

import java.util.Scanner;
    
    public class Main { 
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String[] tmp = sc.nextLine().trim().split(" ");
            int start = Integer.parseInt(tmp[0]);
            int end = Integer.parseInt(tmp[1]);
            int t = 0;
            for (int i = 2;; i++) {
                if (f(i)) {
                    t++;
                    if (t > end) {
                        break;
                    } else if (t >= start) {
                        if (t == end) {
                            System.out.print(i);
                        } else if ((t - start) != 0 && (t - start + 1) % 10 == 0) {
                            System.out.println(i);
                        } else {
                            System.out.print(i + " ");
                        }
                    }
                }
            }
        }
    
        private static boolean f(int num) {
            //筛选掉所有非2偶数
            if (num != 2 && num % 2 == 0) {
                return false;
            }
            for (int i = 3; i <= Math.sqrt(num); i++) {
                if (num % i == 0) {
                    return false;
                }
            }
            return true;
        }
    }

--------------------

### 1021 各位数统计 ###

**问题描述：**

给定一个k位整数N = dk-1\*10k-1 + … + d1\*101 + d0 (0<=di<=9, i=0,…,k-1, dk-1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定N = 100311，则有2个0，3个1，和1个3。

**输入格式：**

每个输入包含1个测试用例，即一个不超过1000位的正整数N。

**输出格式：**

对N中每一种不同的个位数字，以D:M的格式在一行中输出该位数字D及其在N中出现的次数M。要求按D的升序输出。

**输入样例：**

100311

**输出样例：**

0:2
    1:3
    3:1

**提示：**

PAT上题目不推荐使用JAVA语言，本题就非常容易超时（我是多次提交后凑巧AC），推荐使用C或C++将其改写。

除此之外，PAT上使用JAVA语言**千万不要**使用Scanner输入，否则会使得超时问题雪上加霜！！

**Code：**

--------------------

### 1031 查验身份证 ###

**Problem:**  
一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：

首先对前17位数字加权求和，权重分配为：\{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2\}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：

Z：0 1 2 3 4 5 6 7 8 9 10  
M：1 0 X 9 8 7 6 5 4 3 2

现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

**输入格式：**

输入第一行给出正整数N（<= 100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。

**输出格式：**

按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出“All passed”。

**输入样例1：**

4
    320124198808240056
    12010X198901011234
    110108196711301866
    37070419881216001X

**输出样例1：**

12010X198901011234
    110108196711301866
    37070419881216001X

**输入样例2：**

2
    320124198808240056
    110108196711301862

**输出样例2：**

All passed

**Code:**

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));
            int[] a = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
            char[] m = { '1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2' };
            int n = Integer.parseInt(br.readLine());
            boolean flag = true;
            while (n-- > 0) {
                String tmp = br.readLine();
                int rs = 0;
                for (int i = 0; i < 17; i++) {
                    rs += a[i] * (tmp.charAt(i) - '0');
                }
                if (m[rs % 11] != tmp.charAt(17)) {
                    System.out.println(tmp);
                    flag = false;
                }
            }
            if (flag)
                System.out.println("All passed");
            br.close();
        }
    }

--------------------

### 1036 和奥巴马一起编程 ###

**问题描述：**

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

**输入格式：**

输入在一行中给出正方形边长N（3<=N<=20）和组成正方形边的某种字符C，间隔一个空格。

**输出格式：**

输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的50%（四舍五入取整）。

**输入样例：**

10 a

**输出样例：**

aaaaaaaaaa
    a        a
    a        a
    a        a
    aaaaaaaaaa

**Code：**

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[] tmp = br.readLine().trim().split(" ");
            int n = Integer.parseInt(tmp[0]);
            for (int i = 0; i < Math.round(1.0 * n / 2); i++)
                for (int j = 0; j < n; j++) {
                    if (i != 0 && i != Math.round(1.0 * n / 2) - 1) {
                        if (j == 0 || j == n - 1) {
                            System.out.print(tmp[1]);
                        } else {
                            System.out.print(" ");
                        }
                    } else {
                        System.out.print(tmp[1]);
                    }
                    if (j == n - 1) {
                        System.out.println();
                    }
                }
            br.close();
        }
    }

--------------------

### 1041 考试座位号 ###

**问题描述：**

每个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

**Code：**

import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.util.HashMap;
    import java.util.Map;
    
    public class Main { 
        public static void main(String[] args) throws IOException {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            Map<String, String[]> map = new HashMap<>();
            int n = Integer.parseInt(br.readLine());
            while (n-- > 0) {
                String[] tmp = br.readLine().trim().split(" ");
                String[] ss = { tmp[0], tmp[2] };
                map.put(tmp[1], ss);
            }
    
            int m = Integer.parseInt(br.readLine());
            String[] tmp = br.readLine().trim().split(" ");
            for (String key : tmp) {
                String[] ss = map.get(key);
                System.out.println(ss[0] + " " + ss[1]);
            }
            br.close();
        }
    }

--------------------

### 1046 划拳 ###

**问题描述：**

划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就赢了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。

下面给出甲、乙两人的划拳记录，请你统计他们最后分别喝了多少杯酒。

**输入格式：**

输入第一行先给出一个正整数N（<=100），随后N行，每行给出一轮划拳的记录，格式为：

甲喊 甲划 乙喊 乙划

其中“喊”是喊出的数字，“划”是划出的数字，均为不超过100的正整数（两只手一起划）。

**输出格式：**

在一行中先后输出甲、乙两人喝酒的杯数，其间以一个空格分隔。

**输入样例：**

5
    8 10 9 12
    5 10 5 10
    3 8 5 12
    12 18 1 13
    4 16 12 15

**输出样例：**

1 2

**Code：**

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));
            int n = Integer.parseInt(br.readLine());
            String[] tmp;
            int aSpeak, aDo, bSpeak, bDo, sumSpeak;
            int sumA = 0, sumB = 0;
            while (n-- > 0) {
                tmp = br.readLine().trim().split(" ");
                aSpeak = Integer.parseInt(tmp[0]);
                aDo = Integer.parseInt(tmp[1]);
                bSpeak = Integer.parseInt(tmp[2]);
                bDo = Integer.parseInt(tmp[3]);
                sumSpeak = aSpeak + bSpeak;
                if ((aDo != sumSpeak && bDo != sumSpeak) || (aDo == sumSpeak && bDo == sumSpeak)) {
                    continue;
                }
                if (aDo == sumSpeak) {
                    sumB++;
                } else {
                    sumA++;
                }
            }
            System.out.println(sumA + " " + sumB);
            br.close();
        }
    }

--------------------

### 1067 试密码 ###

**问题描述：**

当你试图登录某个系统却忘了密码时，系统一般只会允许你尝试有限多次，当超出允许次数时，账号就会被锁死。本题就请你实现这个小功能。

**输入格式：**

输入在第一行给出一个密码（长度不超过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

**Code：**

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[] tmp = br.readLine().trim().split(" ");
            String answer = tmp[0];
            int n = Integer.parseInt(tmp[1]);
            boolean hasSuccess = false;
    
            while (n-- > 0) {
                String input = br.readLine();
                if ("#".equals(input)) {
                    break;
                }
                if (answer.equals(input)) {
                    System.out.println("Welcome in");
                    hasSuccess = true;
                    break;
                } else {
                    System.out.println("Wrong password: " + input);
                }
            }
            if (n == -1 && hasSuccess == false) {
                System.out.println("Account locked");
            }
            br.close();
        }
    }