PTA乙级1095

1095

PAT 准考证号由 4 部分组成：

第 1 位是级别，即 T 代表顶级；A 代表甲级；B 代表乙级；
第 2~4 位是考场编号，范围从 101 到 999；
第 5~10 位是考试日期，格式为年、月、日顺次各占 2 位；
最后 11~13 位是考生编号，范围从 000 到 999。
现给定一系列考生的准考证号和他们的成绩，请你按照要求输出各种统计信息。

输入格式：

输入首先在一行中给出两个正整数 N（≤10
​4
​​ ）和 M（≤100），分别为考生人数和统计要求的个数。

接下来 N 行，每行给出一个考生的准考证号和其分数（在区间 [0,100] 内的整数），其间以空格分隔。

考生信息之后，再给出 M 行，每行给出一个统计要求，格式为：类型 指令，其中

类型 为 1 表示要求按分数非升序输出某个指定级别的考生的成绩，对应的 指令 则给出代表指定级别的字母；
类型 为 2 表示要求将某指定考场的考生人数和总分统计输出，对应的 指令 则给出指定考场的编号；
类型 为 3 表示要求将某指定日期的考生人数分考场统计输出，对应的 指令 则给出指定日期，格式与准考证上日期相同。

输出格式：

对每项统计要求，首先在一行中输出 Case #: 要求，其中 # 是该项要求的编号，从 1 开始；要求 即复制输入给出的要求。随后输出相应的统计结果：

类型 为 1 的指令，输出格式与输入的考生信息格式相同，即 准考证号 成绩。对于分数并列的考生，按其准考证号的字典序递增输出（题目保证无重复准考证号）；
类型 为 2 的指令，按 人数 总分 的格式输出；
类型 为 3 的指令，输出按人数非递增顺序，格式为 考场编号 总人数。若人数并列则按考场编号递增顺序输出。
如果查询结果为空，则输出 NA。

输入样例：

8 4
B123180908127 99
B102180908003 86
A112180318002 98
T107150310127 62
A107180908108 100
T123180908010 78
B112160918035 88
A107180908021 98
1 A
2 107
3 180908
2 999

输出样例：

Case 1: 1 A
A107180908108 100
A107180908021 98
A112180318002 98
Case 2: 2 107
3 260
Case 3: 3 180908
107 2
123 2
102 1
Case 4: 2 999
NA

思路:这题难度还不算太大就是要判断的有点多,而且做的时候思路不是很清晰,排序有两个用的冒泡排序虽说数量少才用的,但还是有点不合适,但我也不知道能用那些别的.

代码;

package Test_PTA_1062to1095;

import test.S;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class PTA1095 {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String[] a=br.readLine().split(" ");
        int N=Integer.parseInt(a[0]);
        int M=Integer.parseInt(a[1]);
        String[] stu=new String[N];
        for(int i=0;i<N;i++){
            stu[i]=br.readLine();
        }
        for(int i=0;i<M;i++){//M次要求
            String yq=br.readLine();//获取要求

            //条件为1
            if(yq.split(" ")[0].equals("1")){
                System.out.println();
                String[] case1=new String[N];
                int m=0;
                for(int j=0;j<N;j++){
                    if(stu[j].split(" ")[0].split("")[0].equals(yq.split(" ")[1])){//将符合条件的学生放入新数组
                        case1[m]=stu[j];
                        m++;
                    }
                }
                //冒泡排序
                for(int l=0;l<m;l++) {
                    for (int j = 1; j < m-l; j++) {
                        //为了方便书写先定义下
                        int after = Integer.parseInt(case1[j].split(" ")[1]);
                        int before = Integer.parseInt(case1[j - 1].split(" ")[1]);
                        //比较总分
                        if (after > before) {
                            String temp = case1[j];
                            case1[j] = case1[j - 1];
                            case1[j - 1] = temp;
                        }
                        //比较名字
                        else if (after==before) {
                            if ((case1[j].split(" ")[0]).compareTo(case1[j - 1].split(" ")[0]) < 0) {
                                String temp = case1[j];
                                case1[j] = case1[j - 1];
                                case1[j - 1] = temp;
                            }
                        }
                    }
                }
                //输出
                System.out.println("Case "+(i+1)+": "+yq);
                for(int j=0;j<m-1;j++){
                    System.out.println(case1[j]);
                }
                System.out.print(case1[m-1]);//为了输出没有多余换行
            }
            //条件2
            else if (yq.split(" ")[0].equals("2")){
                System.out.println();
                int count=0;
                int sum=0;
                for(int j=0;j<N;j++){
                    String kh=stu[j].split(" ")[0];//考号
                    StringBuilder sbkc=new StringBuilder();//用于保存考场号
                    //获取考场号
                    for (int l=1;l<4;l++){
                        sbkc.append(kh.split("")[l]);
                    }
                    //根据考场号判断获取数据
                    if (sbkc.toString().equals(yq.split(" ")[1])){
                        count++;
                        sum+=Integer.parseInt(stu[j].split(" ")[1]);
                    }
                }
                //输出
                System.out.println("Case " + (i + 1) + ": " + yq);
                if(count!=0) {
                    System.out.print(count + " " + sum);
                }else {
                    System.out.print("NA");
                }
            }
            //条件3
            else if (yq.split(" ")[0].equals("3")){
                System.out.println();
                int[] x=new int[1000];//存放序号对应考场的数量
                int count=0;
                for(int l=0;l<1000;l++){
                    x[l]=0;
                }
                for(int j=0;j<N;j++) {
                    String kh = stu[j].split(" ")[0];//考号
                    StringBuilder sbkc = new StringBuilder();//用于保存考场号
                    StringBuilder rq=new StringBuilder();//保存日期
                    for (int l=1;l<4;l++){//编号
                        sbkc.append(kh.split("")[l]);
                    }
                    for (int l=4;l<10;l++){//日期
                        rq.append(kh.split("")[l]);
                    }
                    if(rq.toString().equals(yq.split(" ")[1])){//满足日期
                        x[Integer.parseInt(sbkc.toString())]++;
                    }
                }
                for(int j=0;j<1000;j++){
                    if(x[j]!=0){
                        count++;
                    }
                }
                int[][] result=new int[count][2];
                int d=0;
                for(int j=0;j<1000;j++){
                    if(x[j]!=0){
                        result[d][0]=j;
                        result[d][1]=x[j];
                        d++;
                    }
                }
                //有点迷糊就直接冒泡排序解决了
                for(int j=0;j<count;j++){
                    for(int l=1;l<count-j;l++){
                        if(result[l][1]>result[l-1][1]){
                            int temp=result[l][1];
                            int temp1=result[l][0];
                            result[l][1]=result[l-1][1];
                            result[l][0]=result[l-1][0];
                            result[l-1][1]=temp;
                            result[l-1][0]=temp1;
                        }
                    }
                }
                //结果
                System.out.println("Case "+(i+1)+": "+yq);
                for (int j=0;j<count-1;j++){
                    System.out.println(result[j][0]+" "+result[j][1]);
                }
                System.out.print(result[count-1][0]+" "+result[count-1][1]);//为了输出没有多余换行//好像还是避免不了最后一个换行..
            }
        }
    }
}