【PAT乙】2022秋季赛后总结-阿里云开发者社区

【PAT乙】2022秋季赛后总结

2022-10-08 99

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 这个暑假博主利用见习和闲暇的时间刷完了PAT乙级的110道题目，首先来说说我的感受吧，题目呢不是很难涉及到的知识点呢也不多，像一些常见的HashMap，数组，自定义类，大数，排序，双指针，重写CompareTo方法都是常考点，乙级也没有涉及什么复杂的数据结构，最多也就考考链表，真题呢博主做了今年的春季和夏季赛，感觉春季难度和这次的秋季难度差不多，夏季赛应该算是最难的了，其中最后一道手撸操作系统中的LRU缓存算法，实属是把我看懵逼了，好在这次秋季赛难度一般，做起来感觉还是比较顺利的！

PAT乙110题专栏：PAT乙（JAVA题解）

✨前言

这个暑假博主利用见习和闲暇的时间刷完了PAT乙级的110道题目，首先来说说我的感受吧，题目呢不是很难涉及到的知识点呢也不多，像一些常见的HashMap，数组，自定义类，大数，排序，双指针，重写CompareTo方法都是常考点，乙级也没有涉及什么复杂的数据结构，最多也就考考链表，真题呢博主做了今年的春季和夏季赛，感觉春季难度和这次的秋季难度差不多，夏季赛应该算是最难的了，其中最后一道手撸操作系统中的LRU缓存算法，实属是把我看懵逼了，好在这次秋季赛难度一般，做起来感觉还是比较顺利的！

👉🏻历史回顾👈🏻

PAT乙级

PAT乙级【Java题解合集】_小羊不会飞的博客

✏️真题回忆

因为题目忘记复制和截图了，下面仅凭博主残缺的记忆以及IDEA里的题解代码，来写下述的总结，敬请谅解！！

🎈第一题

package PAT乙2022秋季;
import java.io.*;
/**
 * @author yx
 * @date 2022-09-04 13:25
 */
public class NO1 {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    public static void main(String[] args) throws IOException {
        in.nextToken();int a0=(int) in.nval;
        in.nextToken();int n=(int) in.nval;
        for (int i = 0; i < n; i++) {
            a0=sum_i(a0*a0*a0+1);
        }
        System.out.println(a0);
    }
    static int sum_i(int n){
        int sum=0;
        while (n!=0){
            sum+=n%10;
            n=n/10;
        }
        return sum;
    }
}

第一题非常基础，求每个数字的各个位数上的数字之后，然后以数列的形式展现，直接一个迭代就完事儿了。

🎈第二题

package PAT乙2022秋季;
import java.io.*;
import java.util.ArrayList;
import java.util.HashSet;
/**
 * @author yx
 * @date 2022-09-04 13:32
 */
public class NO2 {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    public static void main(String[] args) throws IOException {
        in.nextToken();int m=(int) in.nval;
        in.nextToken();int k=(int) in.nval;
        String[] split=ins.readLine().split("");
        HashSet<Integer> set=new HashSet<>();
        int n=0;
        int ans=0;
        for (int i = 0; i < m; i++) {
            if(split[i].equals("A")){
                n=bHua_A(n);
                set.add(n);
            }else {
                n=bHua_B(n);
                set.add(n);
            }
//            System.out.println(n);
        }
        ArrayList<Integer> list=new ArrayList<>(set);
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i)<=k){
                ans++;
//                System.out.print(list.get(i)+" ");
            }
        }
        System.out.println(ans);
    }
    static int bHua_A(int n){
        return n/4;
    }
    static int bHua_B(int n){
        return (8*n+1);
    }
}

第二题是一个字符串+数组的题目吧，大概的意思是给你一串字符，分别由A和B组成，然后遍历，当字符串，当字符为A时对应的A操作，当字符为B时对应的B操作，最后将每次操作过后的数字存进set中，最后统计这些数字中小于k的个数！

🎈第三题

package PAT乙2022秋季;
import com.sun.deploy.util.SyncAccess;
import com.sun.xml.internal.bind.v2.runtime.reflect.Lister;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
/**
 * @author yx
 * @date 2022-09-04 13:54
 */
public class NO3 {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    public static void main(String[] args) throws IOException {
        in.nextToken();int N=(int) in.nval;
        in.nextToken();int a=(int) in.nval;
        in.nextToken();int b=(int) in.nval;
        int max_fwn=0;
        int max_fww=0;
        int min_fww=100000000;
        boolean flag=false;
        int count=0;
        HashMap<Integer,ArrayList<String>> map=new HashMap<>();
        ArrayList<String> list=new ArrayList<>();
        for (int i = 0; i < N; i++) {
            String[] split=ins.readLine().split(" ");
            int temp=Integer.parseInt(split[1]);
            if(temp>=a && temp<=b ){
                flag=true;
                count++;
                if(!map.containsKey(temp)) {
                    ArrayList<String> list1=new ArrayList<>();
                    list1.add(split[0]);
                    map.put(temp, list1);
                }else {
                    map.get(temp).add(split[0]);
                }
                if(temp>max_fwn){
                    max_fwn=temp;
                }
            }else {
                if(temp>max_fww){
                    max_fww=temp;
                }
                if(temp<min_fww){
                    min_fww=temp;
                }
            }
        }
        if(flag){
            out.println(count+" "+max_fwn);
            for (int i : map.keySet()) {
                if(i==max_fwn){
                  int length=map.get(i).size();
                  ArrayList<String> list2=map.get(i);
                    for (int j = 0; j < length; j++) {
                        out.println(list2.get(j));
                    }
                }
            }
        }else {
            out.println(min_fww+" "+max_fww);
        }
        out.flush();
    }
}

第三题是一个买月饼的题，类似于Basic Level中的第100道题：1100 校庆，多组数据处理，也是一道很常规的题目，很遗憾的是超时了，最后我想着用自定义类去做，发现还是超时两个点，一看限制时间：200ms，秒懂，直接放弃，Java选手的悲哀！！！

🎈第四题

package PAT乙2022秋季;
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
/**
 * @author yx
 * @date 2022-09-04 14:26
 */
public class NO4 {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    public static void main(String[] args) throws IOException {
        in.nextToken();int n=(int) in.nval;
        in.nextToken();int h=(int) in.nval;
//        HashMap<Integer,Integer> map=new HashMap<>();
        ArrayList<Integer> list=new ArrayList<>();
        int max_numbers=0;
        int x_=0;
        int duoYu=0;
        //读入数据
        for (int i = 0; i < n; i++) {
            in.nextToken();int temp=(int) in.nval;
            list.add(temp);
        }
        for (int i = 0; i < n ; i++) {
            int temp1=list.get(i);
            for (int j = i; j < n; j++) {
                int temp2=list.get(j);
                if(temp1+h>=temp2){
                    if(j-i+1>max_numbers){
                        max_numbers=j-i+1;
                        x_=temp1;
                        duoYu=temp1+h-temp2;
                    }
                }
            }
        }
        out.println((x_-duoYu)+" "+max_numbers);
        out.flush();
    }
}

第四题有点滑动窗口的意思，其实也就是一个区间问题，在110题中也有出现，具体是哪一个题目我有点忘记了，这种题LeetCode上也碰到过很多次,题目不难，但还是超时了两个点，没拿到满分，原因不言而喻限时：200ms，Java选手再一次自觉的选择了pass！

🎈第五题

package PAT乙2022秋季;
import java.io.*;
import java.util.Arrays;
/**
 * @author yx
 * @date 2022-09-04 14:52
 */
public class NO5 {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    public static void main(String[] args) throws IOException {
        in.nextToken();int n=(int) in.nval;
        boolean isTrue=false;
        for (int i = 0; i < n; i++) {
            in.nextToken();
            int m = (int) in.nval;
            int[] nums = new int[m];
            int flag = 0;
            for (int j = 0; j < m; j++) {
                in.nextToken();
                nums[j] = (int) in.nval;
            }
            int[] temp = Arrays.copyOf(nums, m);
            Arrays.sort(temp);
            for (int j = 1; j < m - 1; j++) {
                isTrue = false;
                if (temp[0] == nums[0] && temp[m - 1] == nums[m - 1]) {
                    System.out.println("Yes");
                    isTrue = true;
                    break;
                }
                if (temp[j] == nums[j] && nums[j]>=temp[j-1] && nums[j]<=temp[j+1]) {
                    if (temp[0] == nums[0] && temp[m - 1] != nums[m - 1]) {
                        System.out.println("Yes");
                        isTrue = true;
                        break;
                    }
                    if (temp[0] != nums[0] && temp[m - 1] == nums[m - 1]) {
                        System.out.println("Yes");
                        isTrue = true;
                        break;
                    }
                    flag++;
                }
            }
            if (!isTrue) {
                if (flag == 3) {
                    System.out.println("Yes");
                } else {
                    System.out.println("No");
                }
            }
        }
    }
}

最后一题是一道快速排序的题目，类似于Basic Level的第35题PTA，但是很遗憾，这道题目我有两个点没拿到，看了一会还是找不出原因，于是就准备交卷跑路了，后续坐等满分大神出题解！

📖总结与分享

Java真的不适合写算法（至少不适合PAT），虽然它有很多非常香的API可以用，但是真的太慢了，因为底层有一个Java虚拟机，即使我已经使用IO流去接收数据了，但在PAT上面只要有限时200ms以下的题目必超时两个点，Java选手的的悲哀莫过于此，这次秋季赛就栽了，第三题和第四题都超时两个点（因为超时多扣了10分，祭！！），本来还想优化一下，一看限时200ms，秒懂，直接提前交卷，下图Basic Level只拿到了2095分，剩下的105分都是Java的超时导致的！