PAT – 第2页 – 柳婼の blog

[Java] 1022. Digital Library (30)-PAT甲级

1022. Digital Library (30)
A Digital Library contains millions of books, stored according to their titles, authors, key words of their abstracts, publishers, and published years. Each book is assigned an unique 7-digit number as its ID. Given any query from a reader, you are supposed to output the resulting books, sorted in increasing order of their ID’s.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (<=10000) which is the total number of books. Then N blocks follow, each contains the information of a book in 6 lines:

Line #1: the 7-digit ID number;
Line #2: the book title — a string of no more than 80 characters;
Line #3: the author — a string of no more than 80 characters;
Line #4: the key words — each word is a string of no more than 10 characters without any white space, and the keywords are separated by exactly one space;
Line #5: the publisher — a string of no more than 80 characters;
Line #6: the published year — a 4-digit number which is in the range [1000, 3000].
It is assumed that each book belongs to one author only, and contains no more than 5 key words; there are no more than 1000 distinct key words in total; and there are no more than 1000 distinct publishers.

After the book information, there is a line containing a positive integer M (<=1000) which is the number of user’s search queries. Then M lines follow, each in one of the formats shown below:

1: a book title
2: name of an author
3: a key word
4: name of a publisher
5: a 4-digit number representing the year
Output Specification:

For each query, first print the original query in a line, then output the resulting book ID’s in increasing order, each occupying a line. If no book is found, print “Not Found” instead.

Sample Input:
3
1111111
The Testing Book
Yue Chen
test code debug sort keywords
ZUCS Print
2011
3333333
Another Testing Book
Yue Chen
test code sort keywords
ZUCS Print2
2012
2222222
The Testing Book
CYLL
keywords debug book
ZUCS Print2
2011
6
1: The Testing Book
2: Yue Chen
3: keywords
4: ZUCS Print
5: 2011
3: blablabla
Sample Output:
1: The Testing Book
1111111
2222222
2: Yue Chen
1111111
3333333
3: keywords
1111111
2222222
3333333
4: ZUCS Print
1111111
5: 2011
1111111
2222222
3: blablabla
Not Found

题目大意：模拟数字图书馆的查询功能。会给出n本书的信息，以及m个需要查询的命令，数字标号对应相应的命令，数字编号后面的字符串是查询的搜索词，要求输出这行命令以及输出满足条件的书的id，如果一个都没有找到，输出Not Found

PS：感谢github用户@fs19910227提供的pull request～

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.TreeSet;

public class Main {
    static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 6 * 1024 * 1024);

    static class Library {
        HashMap<String, TreeSet<String>>[] allMaps = new HashMap[5];

        Library() throws IOException {
            for (int i = 0; i < 5; i++) {
                HashMap<String, TreeSet<String>> map = new HashMap<>(1000, 1);
                allMaps[i] = map;
            }
            int record_size = Integer.valueOf(reader.readLine());
            for (int i = 0; i < record_size; i++) {
                String id = reader.readLine();
                for (int j = 0; j < allMaps.length; j++) {
                    HashMap<String, TreeSet<String>> map = allMaps[j];
                    if (j == 2) {
                        String[] keys = reader.readLine().split(" ");
                        for (String key : keys) {
                            putValue(map, key, id);
                        }
                    } else {
                        String key = reader.readLine();
                        putValue(map, key, id);
                    }
                }
            }
        }

        TreeSet<String> query(int id, String queryString) {
            HashMap<String, TreeSet<String>> allMap = allMaps[id - 1];
            TreeSet<String> integers = allMap.get(queryString);
            return integers;
        }

        private void putValue(HashMap<String, TreeSet<String>> map, String key, String id) {
            TreeSet<String> integers = map.computeIfAbsent(key, k -> new TreeSet<>());
            integers.add(id);
        }
    }

    public static void main(String[] args) throws IOException {
        Library library = new Library();
        int query_size = Integer.valueOf(reader.readLine());
        for (int i = 0; i < query_size; i++) {
            String line = reader.readLine();
            System.out.println(line);
            int id = line.charAt(0) - 48;
            String query = line.substring(3);
            TreeSet<String> queryResult = library.query(id, query);
            if (queryResult == null) {
                System.out.println("Not Found");
            } else {
                for (String book_id : queryResult) {
                    System.out.println(book_id);
                }
            }
        }
    }
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.HashMap;

import java.util.TreeSet;

public class Main {

static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in), 6 * 1024 * 1024);

static class Library {

HashMap<String, TreeSet<String>>[] allMaps = new HashMap[5];

Library() throws IOException {

for (int i = 0; i < 5; i++) {

HashMap<String, TreeSet<String>> map = new HashMap<>(1000, 1);

allMaps[i] = map;

}

int record_size = Integer.valueOf(reader.readLine());

for (int i = 0; i < record_size; i++) {

String id = reader.readLine();

for (int j = 0; j < allMaps.length; j++) {

HashMap<String, TreeSet<String>> map = allMaps[j];

if (j == 2) {

String[] keys = reader.readLine().split(" ");

for (String key : keys) {

putValue(map, key, id);

}

} else {

String key = reader.readLine();

putValue(map, key, id);

}

TreeSet<String> query(int id, String queryString) {

HashMap<String, TreeSet<String>> allMap = allMaps[id - 1];

TreeSet<String> integers = allMap.get(queryString);

return integers;

}

private void putValue(HashMap<String, TreeSet<String>> map, String key, String id) {

TreeSet<String> integers = map.computeIfAbsent(key, k -> new TreeSet<>());

integers.add(id);

}

public static void main(String[] args) throws IOException {

Library library = new Library();

int query_size = Integer.valueOf(reader.readLine());

for (int i = 0; i < query_size; i++) {

String line = reader.readLine();

System.out.println(line);

int id = line.charAt(0) - 48;

String query = line.substring(3);

TreeSet<String> queryResult = library.query(id, query);

if (queryResult == null) {

System.out.println("Not Found");

} else {

for (String book_id : queryResult) {

System.out.println(book_id);

}

[Java] 1020. Tree Traversals (25)-PAT甲级

1020. Tree Traversals (25)
Suppose that all the keys in a binary tree are distinct positive integers. Given the postorder and inorder traversal sequences, you are supposed to output the level order traversal sequence of the corresponding binary tree.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (<=30), the total number of nodes in the binary tree. The second line gives the postorder sequence and the third line gives the inorder sequence. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in one line the level order traversal sequence of the corresponding binary tree. All the numbers in a line must be separated by exactly one space, and there must be no extra space at the end of the line.

Sample Input:
7
2 3 1 5 7 6 4
1 2 3 4 5 6 7
Sample Output:
4 1 6 3 5 7 2

题目大意：给定一棵二叉树的后序遍历和中序遍历，请你输出其层序遍历的序列。这里假设键值都是互不相等的正整数。

PS：感谢github用户@fs19910227提供的pull request～

import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    static Scanner scanner = new Scanner(System.in);

    static class Node {
        int value;
        Node left;
        Node right;

        Node(int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "value=" + value +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }
    }

    private static Node bulidTree() {
        int size = scanner.nextInt();
        int[] postOrder = new int[size];
        int[] inOrder = new int[size];
        for (int i = 0; i < size; i++) {
            postOrder[i] = scanner.nextInt();
        }
        for (int i = 0; i < size; i++) {
            inOrder[i] = scanner.nextInt();
        }
        Node root = build(postOrder, inOrder,
                0, size - 1,
                0, size - 1);
        return root;
    }

    private static Node build(int[] postOrder, int[] inOrder, int postStart, int postEnd, int inStart, int inEnd) {
        if (postStart > postEnd) {
            return null;
        }
        if (postStart == postEnd) {
            return new Node(postOrder[postStart]);
        }
        int root = postOrder[postEnd--];

        //find root in inOrder
        int inIndex = -1;
        for (int i = inStart; i <= inEnd; i++) {
            if (root == inOrder[i]) {
                inIndex = i;
                break;
            }
        }
        //recursion build
        int leftSize = inIndex - inStart;
        int rightSize = inEnd - inIndex;
        Node rootNode = new Node(root);
        rootNode.left = build(postOrder, inOrder,
                postStart, postStart + leftSize - 1,
                inStart, inIndex - 1);
        rootNode.right = build(postOrder, inOrder, postEnd - rightSize + 1, postEnd, inIndex + 1, inEnd);
        return rootNode;
    }

    public static void main(String[] args) {
        Node root = bulidTree();
        LinkedList<Node> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node poll = queue.poll();
            if (poll.left != null) {
                queue.add(poll.left);
            }
            if (poll.right != null) {
                queue.add(poll.right);
            }
            System.out.printf("%d%s", poll.value, queue.isEmpty() ? "\n" : " ");
        }
    }
}

import java.util.LinkedList;

import java.util.Scanner;

public class Main {

static Scanner scanner = new Scanner(System.in);

static class Node {

int value;

Node left;

Node right;

Node(int value) {

this.value = value;

}

@Override

public String toString() {

return "Node{" +

"value=" + value +

", left=" + left +

", right=" + right +

'}';

}

private static Node bulidTree() {

int size = scanner.nextInt();

int[] postOrder = new int[size];

int[] inOrder = new int[size];

for (int i = 0; i < size; i++) {

postOrder[i] = scanner.nextInt();

}

for (int i = 0; i < size; i++) {

inOrder[i] = scanner.nextInt();

}

Node root = build(postOrder, inOrder,

0, size - 1,

0, size - 1);

return root;

}

private static Node build(int[] postOrder, int[] inOrder, int postStart, int postEnd, int inStart, int inEnd) {

if (postStart > postEnd) {

return null;

}

if (postStart == postEnd) {

return new Node(postOrder[postStart]);

}

int root = postOrder[postEnd--];

//find root in inOrder

int inIndex = -1;

for (int i = inStart; i <= inEnd; i++) {

if (root == inOrder[i]) {

inIndex = i;

break;

}

//recursion build

int leftSize = inIndex - inStart;

int rightSize = inEnd - inIndex;

Node rootNode = new Node(root);

rootNode.left = build(postOrder, inOrder,

postStart, postStart + leftSize - 1,

inStart, inIndex - 1);

rootNode.right = build(postOrder, inOrder, postEnd - rightSize + 1, postEnd, inIndex + 1, inEnd);

return rootNode;

}

public static void main(String[] args) {

Node root = bulidTree();

LinkedList<Node> queue = new LinkedList<>();

queue.add(root);

while (!queue.isEmpty()) {

Node poll = queue.poll();

if (poll.left != null) {

queue.add(poll.left);

}

if (poll.right != null) {

queue.add(poll.right);

}

System.out.printf("%d%s", poll.value, queue.isEmpty() ? "\n" : " ");

}

[Java] 1019. General Palindromic Number (20)-PAT甲级

1019. General Palindromic Number (20)
A number that will be the same when it is written forwards or backwards is known as a Palindromic Number. For example, 1234321 is a palindromic number. All single digit numbers are palindromic numbers.

Although palindromic numbers are most often considered in the decimal system, the concept of palindromicity can be applied to the natural numbers in any numeral system. Consider a number N > 0 in base b >= 2, where it is written in standard notation with k+1 digits ai as the sum of (aibi) for i from 0 to k. Here, as usual, 0 <= ai < b for all i and ak is non-zero. Then N is palindromic if and only if ai = ak-i for all i. Zero is written 0 in any base and is also palindromic by definition.

Given any non-negative decimal integer N and a base b, you are supposed to tell if N is a palindromic number in base b.

Input Specification:

Each input file contains one test case. Each case consists of two non-negative numbers N and b, where 0 <= N <= 109 is the decimal number and 2 <= b <= 109 is the base. The numbers are separated by a space.

Output Specification:

For each test case, first print in one line “Yes” if N is a palindromic number in base b, or “No” if not. Then in the next line, print N as the number in base b in the form “ak ak-1 … a0”. Notice that there must be no extra space at the end of output.

Sample Input 1:
27 2
Sample Output 1:
Yes
1 1 0 1 1
Sample Input 2:
121 5
Sample Output 2:
No
4 4 1

题目大意：给出两个整数a和b，问十进制的a在b进制下是否为回文数。是的话输出Yes，不是输出No。并且输出a在b进制下的表示，以空格隔开

PS：感谢github用户@fs19910227提供的pull request～

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

public class Main {
    private static ArrayList<Integer> toPalindromic(int number, int base) {
        ArrayList<Integer> list = new ArrayList<>(31);
        if (number == 0) {
            list.add(0);
            return list;
        }
        while (number != 0) {
            int bit = number % base;
            list.add(bit);
            number = number / base;
        }
        return list;
    }

    static boolean isPalindromic(ArrayList<Integer> list) {
        int length = list.size();
        for (int i = 0, j = length - 1; i < length / 2; i++, j--) {
            if (!list.get(i).equals(list.get(j))) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] split = reader.readLine().split(" ");
        int number = Integer.valueOf(split[0]);
        int base = Integer.valueOf(split[1]);
        ArrayList<Integer> builder = toPalindromic(number, base);
        System.out.println(isPalindromic(builder) ? "Yes" : "No");
        for (int i = builder.size() - 1; i >= 0; i--) {
            System.out.printf("%d%s", builder.get(i), i == 0 ? "\n" : " ");
        }
    }
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.ArrayList;

public class Main {

private static ArrayList<Integer> toPalindromic(int number, int base) {

ArrayList<Integer> list = new ArrayList<>(31);

if (number == 0) {

list.add(0);

return list;

}

while (number != 0) {

int bit = number % base;

list.add(bit);

number = number / base;

}

return list;

}

static boolean isPalindromic(ArrayList<Integer> list) {

int length = list.size();

for (int i = 0, j = length - 1; i < length / 2; i++, j--) {

if (!list.get(i).equals(list.get(j))) {

return false;

}

return true;

}

public static void main(String[] args) throws IOException {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

String[] split = reader.readLine().split(" ");

int number = Integer.valueOf(split[0]);

int base = Integer.valueOf(split[1]);

ArrayList<Integer> builder = toPalindromic(number, base);

System.out.println(isPalindromic(builder) ? "Yes" : "No");

for (int i = builder.size() - 1; i >= 0; i--) {

System.out.printf("%d%s", builder.get(i), i == 0 ? "\n" : " ");

}

[Java] 1015. Reversible Primes (20)-PAT甲级

1015. Reversible Primes (20)
A reversible prime in any number system is a prime whose “reverse” in that number system is also a prime. For example in the decimal system 73 is a reversible prime because its reverse 37 is also a prime.

Now given any two positive integers N (< 105) and D (1 < D <= 10), you are supposed to tell if N is a reversible prime with radix D.

Input Specification:

The input file consists of several test cases. Each case occupies a line which contains two integers N and D. The input is finished by a negative N.

Output Specification:

For each test case, print in one line “Yes” if N is a reversible prime with radix D, or “No” if not.

Sample Input:
73 10
23 2
23 10
-2
Sample Output:
Yes
Yes
No
题目大意：如果一个数本身是素数，而且在d进制下反转后的数在十进制下也是素数，就输出Yes，否则就输出No

PS：感谢github用户@fs19910227提供的pull request～

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

public class Main {
    private boolean isPrime(String number) {
        int value = Integer.valueOf(number);
        if (value <= 1) return false;
        if (value == 2) return true;
        if (value % 2 == 0) return false;
        int maxLimit = (int) Math.sqrt(value);
        for (int i = 3; i <= maxLimit; i += 2) {
            if (value % i == 0) {
                return false;
            }
        }
        return true;
    }

    private String reversePrime(String number, int radix) {
        int value = Integer.valueOf(number);
        StringBuilder builder = new StringBuilder();
        for (; value != 0; value = value / radix) {
            int bit = value % radix;
            builder.append(bit);
        }
        return new BigInteger(builder.toString(), radix).toString();
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        Main rp = new Main();
        String[] split = reader.readLine().split(" ");
        for (; split.length > 1; split = reader.readLine().split(" ")) {
            String number = split[0];
            int radix = Integer.valueOf(split[1]);
            if (rp.isPrime(number) &&
                    rp.isPrime(rp.reversePrime(number, radix))) {
                System.out.println("Yes");
            } else {
                System.out.println("No");
            }
        }
    }
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.math.BigInteger;

public class Main {

private boolean isPrime(String number) {

int value = Integer.valueOf(number);

if (value <= 1) return false;

if (value == 2) return true;

if (value % 2 == 0) return false;

int maxLimit = (int) Math.sqrt(value);

for (int i = 3; i <= maxLimit; i += 2) {

if (value % i == 0) {

return false;

}

return true;

}

private String reversePrime(String number, int radix) {

int value = Integer.valueOf(number);

StringBuilder builder = new StringBuilder();

for (; value != 0; value = value / radix) {

int bit = value % radix;

builder.append(bit);

}

return new BigInteger(builder.toString(), radix).toString();

}

public static void main(String[] args) throws IOException {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

Main rp = new Main();

String[] split = reader.readLine().split(" ");

for (; split.length > 1; split = reader.readLine().split(" ")) {

String number = split[0];

int radix = Integer.valueOf(split[1]);

if (rp.isPrime(number) &&

rp.isPrime(rp.reversePrime(number, radix))) {

System.out.println("Yes");

} else {

System.out.println("No");

}

[Java] 1014. Waiting in Line (30)-PAT甲级

Suppose a bank has N windows open for service. There is a yellow line in front of the windows which devides the waiting area into two parts. The rules for the customers to wait in line are:

The space inside the yellow line in front of each window is enough to contain a line with M customers. Hence when all the N lines are full, all the customers after (and including) the (NM+1)st one will have to wait in a line behind the yellow line.
Each customer will choose the shortest line to wait in when crossing the yellow line. If there are two or more lines with the same length, the customer will always choose the window with the smallest number.
Customer[i] will take T[i] minutes to have his/her transaction processed.
The first N customers are assumed to be served at 8:00am.
Now given the processing time of each customer, you are supposed to tell the exact time at which a customer has his/her business done.

For example, suppose that a bank has 2 windows and each window may have 2 custmers waiting inside the yellow line. There are 5 customers waiting with transactions taking 1, 2, 6, 4 and 3 minutes, respectively. At 08:00 in the morning, customer1 is served at window1 while customer2 is served at window2. Customer3 will wait in front of window1 and customer4 will wait in front of window2. Customer5 will wait behind the yellow line.

At 08:01, customer1 is done and customer5 enters the line in front of window1 since that line seems shorter now. Customer2 will leave at 08:02, customer4 at 08:06, customer3 at 08:07, and finally customer5 at 08:10.

Input

Each input file contains one test case. Each case starts with a line containing 4 positive integers: N (<=20, number of windows), M (<=10, the maximum capacity of each line inside the yellow line), K (<=1000, number of customers), and Q (<=1000, number of customer queries).

The next line contains K positive integers, which are the processing time of the K customers.

The last line contains Q positive integers, which represent the customers who are asking about the time they can have their transactions done. The customers are numbered from 1 to K.

Output

For each of the Q customers, print in one line the time at which his/her transaction is finished, in the format HH:MM where HH is in [08, 17] and MM is in [00, 59]. Note that since the bank is closed everyday after 17:00, for those customers who cannot be served before 17:00, you must output “Sorry” instead.

Sample Input
2 2 7 5
1 2 6 4 3 534 2
3 4 5 6 7
Sample Output
08:07
08:06
08:10
17:00
Sorry

题目大意：n个窗口，每个窗口可以排队m人。有k位用户需要服务，给出了每位用户需要的minute数，所有客户在8点开始服务，如果有窗口还没排满就入队，否则就在黄线外等候。如果有某一列有一个用户走了服务完毕了，黄线外的人就进来一个。如果同时就选窗口数小的。求q个人的服务结束时间。
如果一个客户在17:00以及以后还没有开始服务（此处不是结束服务是开始17:00）就不再服务输出sorry；如果这个服务已经开始了，无论时间多长都要等他服务完毕

PS：感谢github用户@fs19910227提供的pull request～

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedList;

public class Main {
    static class Bank {
        final static int WorkingTime = 9 * 60;
        static final SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        static Date TimeStart;

        static {
            try {
                TimeStart = format.parse("08:00");
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }

        final int window_quantity, window_limit, customer_quantity;
        //客户查询索引
        final int[] customer_index;
        //排队客户 id list
        final LinkedList<Integer>[] queues;

        Bank(int window_quantity, int window_limit, int customer_quantity) {
            this.window_quantity = window_quantity;
            this.window_limit = window_limit;
            this.customer_quantity = customer_quantity;
            this.customer_index = new int[customer_quantity + 1];
            queues = new LinkedList[window_quantity];
            for (int i = 0; i < queues.length; i++) {
                queues[i] = new LinkedList<>();
            }
        }

        /**
         * 根据customer id 获取排队时间
         */
        String index(String id) {
            int idi = Integer.valueOf(id);
            int time_offset = this.customer_index[idi];
            if (time_offset == 0) {
                return "Sorry";
            }
            Calendar instance = Calendar.getInstance();
            instance.setTime(TimeStart);
            instance.add(Calendar.MINUTE, time_offset);
            return format.format(instance.getTime());
        }

        //计算时间
        void calculate(String[] customer_cost_array) {
            //每个队列的时间片
            int[] window_time_offset = new int[window_quantity];

            for (int index = 0;
                 index < customer_quantity;
                 index++) {
                int customer_id = index + 1;
                int customer_cost_time = Integer.valueOf(customer_cost_array[index]);

                int window_index = -1;
                //容量之内,按顺序放
                if (index < window_quantity * window_limit) {
                    window_index = index % window_quantity;
                } else { //容量之外,排在等待时间最小的
                    //求队头最小值,并出队
                    int min_customer_cost = Integer.MAX_VALUE;
                    for (int i = 0; i < window_quantity; i++) {
                        Integer cost = queues[i].peekFirst();
                        if (cost != null && cost < min_customer_cost) {
                            min_customer_cost = cost;
                            window_index = i;
                        }
                    }
                    queues[window_index].removeFirst();
                }
                //能排上队的,记一下时间
                if (window_time_offset[window_index] < WorkingTime) {
                    window_time_offset[window_index] = window_time_offset[window_index] + customer_cost_time;
                    queues[window_index].add(window_time_offset[window_index]);
                    customer_index[customer_id] = window_time_offset[window_index];
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] split = reader.readLine().split(" ");
        Bank bank = new Bank(Integer.valueOf(split[0]), Integer.valueOf(split[1]), Integer.valueOf(split[2]));
        String[] line = reader.readLine().split(" ");
        bank.calculate(line);
        for (String id : reader.readLine().split(" ")) {
            System.out.println(bank.index(id));
        }
    }
}

100

101

102

103

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Date;

import java.util.LinkedList;

public class Main {

static class Bank {

final static int WorkingTime = 9 * 60;

static final SimpleDateFormat format = new SimpleDateFormat("HH:mm");

static Date TimeStart;

static {

try {

TimeStart = format.parse("08:00");

} catch (ParseException e) {

e.printStackTrace();

}

final int window_quantity, window_limit, customer_quantity;

//客户查询索引

final int[] customer_index;

//排队客户 id list

final LinkedList<Integer>[] queues;

Bank(int window_quantity, int window_limit, int customer_quantity) {

this.window_quantity = window_quantity;

this.window_limit = window_limit;

this.customer_quantity = customer_quantity;

this.customer_index = new int[customer_quantity + 1];

queues = new LinkedList[window_quantity];

for (int i = 0; i < queues.length; i++) {

queues[i] = new LinkedList<>();

}

/**

* 根据customer id 获取排队时间

String index(String id) {

int idi = Integer.valueOf(id);

int time_offset = this.customer_index[idi];

if (time_offset == 0) {

return "Sorry";

}

Calendar instance = Calendar.getInstance();

instance.setTime(TimeStart);

instance.add(Calendar.MINUTE, time_offset);

return format.format(instance.getTime());

}

//计算时间

void calculate(String[] customer_cost_array) {

//每个队列的时间片

int[] window_time_offset = new int[window_quantity];

for (int index = 0;

index < customer_quantity;

index++) {

int customer_id = index + 1;

int customer_cost_time = Integer.valueOf(customer_cost_array[index]);

int window_index = -1;

//容量之内,按顺序放

if (index < window_quantity * window_limit) {

window_index = index % window_quantity;

} else { //容量之外,排在等待时间最小的

//求队头最小值,并出队

int min_customer_cost = Integer.MAX_VALUE;

for (int i = 0; i < window_quantity; i++) {

Integer cost = queues[i].peekFirst();

if (cost != null && cost < min_customer_cost) {

min_customer_cost = cost;

window_index = i;

}

queues[window_index].removeFirst();

}

//能排上队的,记一下时间

if (window_time_offset[window_index] < WorkingTime) {

window_time_offset[window_index] = window_time_offset[window_index] + customer_cost_time;

queues[window_index].add(window_time_offset[window_index]);

customer_index[customer_id] = window_time_offset[window_index];

}

public static void main(String[] args) throws IOException {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

String[] split = reader.readLine().split(" ");

Bank bank = new Bank(Integer.valueOf(split[0]), Integer.valueOf(split[1]), Integer.valueOf(split[2]));

String[] line = reader.readLine().split(" ");

bank.calculate(line);

for (String id : reader.readLine().split(" ")) {

System.out.println(bank.index(id));

}

[Java] 1012. The Best Rank (25)-PAT甲级

1012. The Best Rank (25)
To evaluate the performance of our first year CS majored students, we consider their grades of three courses only: C – C Programming Language, M – Mathematics (Calculus or Linear Algebra), and E – English. At the mean time, we encourage students by emphasizing on their best ranks — that is, among the four ranks with respect to the three courses and the average grade, we print the best rank for each student.

For example, The grades of C, M, E and A – Average of 4 students are given as the following:

StudentID C M E A
310101 98 85 88 90
310102 70 95 88 84
310103 82 87 94 88
310104 91 91 91 91
Then the best ranks for all the students are No.1 since the 1st one has done the best in C Programming Language, while the 2nd one in Mathematics, the 3rd one in English, and the last one in average.

Input

Each input file contains one test case. Each case starts with a line containing 2 numbers N and M (<=2000), which are the total number of students, and the number of students who would check their ranks, respectively. Then N lines follow, each contains a student ID which is a string of 6 digits, followed by the three integer grades (in the range of [0, 100]) of that student in the order of C, M and E. Then there are M lines, each containing a student ID.

Output

For each of the M students, print in one line the best rank for him/her, and the symbol of the corresponding rank, separated by a space.

The priorities of the ranking methods are ordered as A > C > M > E. Hence if there are two or more ways for a student to obtain the same best rank, output the one with the highest priority.

If a student is not on the grading list, simply output “N/A”.

Sample Input
5 6
310101 98 85 88
310102 70 95 88
310103 82 87 94
310104 91 91 91
310105 85 90 90
310101
310102
310103
310104
310105
999999
Sample Output
1 C
1 M
1 E
1 A
3 A
N/A

题目大意：现已知n个考生的3门分数，平均分可以按照这三门算出来。然后分别对这四个分数从高到低排序，这样对每个考生来说有4个排名。k个查询，对于每一个学生id，输出当前id学生的最好的排名和它对应的分数，如果名次相同，按照A>C>M>E的顺序输出。如果当前id不存在，输出N/A

PS：感谢github用户@fs19910227提供的pull request～

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.stream.Stream;

public class Main {
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    static class Course {
        enum Name {
            C(2), M(3), E(4), A(1);
            final int rank;

            Name(int rank) {
                this.rank = rank;
            }
        }

        static Name[] names = Name.values();
        final int score;
        final int course_rank;
        final int id;
        final String name;

        Course(int id, int score) {
            this.score = score;
            this.course_rank = names[id].rank;
            this.id = id;
            this.name = names[id].toString();
        }
    }

    static class Student {
        String id;
        Course[] courses;

        Student(String id, Course[] courses) {
            this.id = id;
            this.courses = courses;
        }
    }

    static String readLine() throws IOException {
        return reader.readLine();
    }

    public static void main(String[] args) throws IOException {
        String[] split = readLine().split(" ");
        int student_nums = Integer.valueOf(split[0]);
        int check_student = Integer.valueOf(split[1]);

        //偷个懒,就都用数组存储
        //score  table
        //0,1,2,3 => C,M,E,A
        //[0-100] score=>counts
        int[][] scoreTable = new int[4][101];
        //course,score=>course_rank
        int[][] rankTable = new int[4][101];

        HashMap<String, Student> students = new HashMap<>(1024, 1);
        for (int i = 0; i < student_nums; i++) {
            String[] line = readLine().split(" ");
            String id = line[0];

            //准备课程
            Course[] courses = new Course[4];
            int sum = 0, index = 0;
            for (int j = 1; j < line.length; j++, index++) {
                Integer score = Integer.valueOf(line[j]);
                sum += score;
                courses[index] = new Course(index, score);
                scoreTable[index][score]++;
            }
            //处理平均值
            int avg_score = sum / index;
            courses[index] = new Course(index, avg_score);
            scoreTable[index][avg_score]++;
            //准备学生
            Student student = new Student(id, courses);
            //存储学生
            students.put(id, student);
        }
        //计算rank
        for (int i = 0; i < scoreTable.length; i++) {
            int[] scores = scoreTable[i];
            int rank = 1;
            for (int j = scores.length - 1; j >= 0; j--) {
                int counts = scores[j];
                if (counts > 0) {
                    rankTable[i][j] = rank;
                    rank += counts;
                }
            }
        }
        for (int i = 0; i < check_student; i++) {
            String id = readLine();
            Student student = students.get(id);
            if (student == null) {
                System.out.println("N/A");
            } else {
                Course course = Stream.of(student.courses).min((o1, o2) -> {
                    int rank_1 = rankTable[o1.id][o1.score];
                    int rank_2 = rankTable[o2.id][o2.score];
                    int compare = rank_1 - rank_2;
                    return compare == 0 ? o1.course_rank - o2.course_rank : compare;
                }).get();
                int rank = rankTable[course.id][course.score];
                System.out.println(rank + " " + course.name);
            }
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.HashMap;

import java.util.stream.Stream;

public class Main {

private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

static class Course {

enum Name {

C(2), M(3), E(4), A(1);

final int rank;

Name(int rank) {

this.rank = rank;

}

static Name[] names = Name.values();

final int score;

final int course_rank;

final int id;

final String name;

Course(int id, int score) {

this.score = score;

this.course_rank = names[id].rank;

this.id = id;

this.name = names[id].toString();

}

static class Student {

String id;

Course[] courses;

Student(String id, Course[] courses) {

this.id = id;

this.courses = courses;

}

static String readLine() throws IOException {

return reader.readLine();

}

public static void main(String[] args) throws IOException {

String[] split = readLine().split(" ");

int student_nums = Integer.valueOf(split[0]);

int check_student = Integer.valueOf(split[1]);

//偷个懒,就都用数组存储

//score table

//0,1,2,3 => C,M,E,A

//[0-100] score=>counts

int[][] scoreTable = new int[4][101];

//course,score=>course_rank

int[][] rankTable = new int[4][101];

HashMap<String, Student> students = new HashMap<>(1024, 1);

for (int i = 0; i < student_nums; i++) {

String[] line = readLine().split(" ");

String id = line[0];

//准备课程

Course[] courses = new Course[4];

int sum = 0, index = 0;

for (int j = 1; j < line.length; j++, index++) {

Integer score = Integer.valueOf(line[j]);

sum += score;

courses[index] = new Course(index, score);

scoreTable[index][score]++;

}

//处理平均值

int avg_score = sum / index;

courses[index] = new Course(index, avg_score);

scoreTable[index][avg_score]++;

//准备学生

Student student = new Student(id, courses);

//存储学生

students.put(id, student);

}

//计算rank

for (int i = 0; i < scoreTable.length; i++) {

int[] scores = scoreTable[i];

int rank = 1;

for (int j = scores.length - 1; j >= 0; j--) {

int counts = scores[j];

if (counts > 0) {

rankTable[i][j] = rank;

rank += counts;

}

for (int i = 0; i < check_student; i++) {

String id = readLine();

Student student = students.get(id);

if (student == null) {

System.out.println("N/A");

} else {

Course course = Stream.of(student.courses).min((o1, o2) -> {

int rank_1 = rankTable[o1.id][o1.score];

int rank_2 = rankTable[o2.id][o2.score];

int compare = rank_1 - rank_2;

return compare == 0 ? o1.course_rank - o2.course_rank : compare;

}).get();

int rank = rankTable[course.id][course.score];

System.out.println(rank + " " + course.name);

}