柳婼の blog – 第87页 – 我不管，反正我最萌～

[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);

}

[Java] 1011. World Cup Betting (20)-PAT甲级

1011. World Cup Betting (20)
With the 2010 FIFA World Cup running, football fans the world over were becoming increasingly excited as the best players from the best teams doing battles for the World Cup trophy in South Africa. Similarly, football betting fans were putting their money where their mouths were, by laying all manner of World Cup bets.

Chinese Football Lottery provided a “Triple Winning” game. The rule of winning was simple: first select any three of the games. Then for each selected game, bet on one of the three possible results — namely W for win, T for tie, and L for lose. There was an odd assigned to each result. The winner’s odd would be the product of the three odds times 65%.

For example, 3 games’ odds are given as the following:

W T L
1.1 2.5 1.7
1.2 3.0 1.6
4.1 1.2 1.1
To obtain the maximum profit, one must buy W for the 3rd game, T for the 2nd game, and T for the 1st game. If each bet takes 2 yuans, then the maximum profit would be (4.1*3.0*2.5*65%-1)*2 = 37.98 yuans (accurate up to 2 decimal places).

Input

Each input file contains one test case. Each case contains the betting information of 3 games. Each game occupies a line with three distinct odds corresponding to W, T and L.

Output

For each test case, print in one line the best bet of each game, and the maximum profit accurate up to 2 decimal places. The characters and the number must be separated by one space.

Sample Input
1.1 2.5 1.7
1.2 3.0 1.6
4.1 1.2 1.1
Sample Output
T T W 37.98

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

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

public class Main {
    static class Bet {
        static String[] names = new String[]{"W", "T", "L"};
        String name;
        double value;

        Bet(int index, double value) {
            this.name = names[index];
            this.value = value;
        }
    }

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

    public static void main(String[] args) throws IOException {
        StringBuilder builder = new StringBuilder();
        double sum = 1;
        for (int i = 0; i < 3; i++) {
            Bet bet = getBet();
            builder.append(bet.name).append(" ");
            sum = sum * bet.value;
        }
        double profit = 2 * (sum * 0.65 - 1);
        //四舍五入就可以, 可以无视example
        builder.append(String.format("%.2f", profit));
        System.out.println(builder);
    }

    private static Bet getBet() throws IOException {
        String[] split = reader.readLine().split(" ");
        int max_index = 0;
        double max_bet = -1.0;
        for (int i = 0; i < split.length; i++) {
            double v = Double.valueOf(split[i]);
            if (v > max_bet) {
                max_index = i;
                max_bet = v;
            }
        }
        return new Bet(max_index, max_bet);
    }
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

static class Bet {

static String[] names = new String[]{"W", "T", "L"};

String name;

double value;

Bet(int index, double value) {

this.name = names[index];

this.value = value;

}

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

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

StringBuilder builder = new StringBuilder();

double sum = 1;

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

Bet bet = getBet();

builder.append(bet.name).append(" ");

sum = sum * bet.value;

}

double profit = 2 * (sum * 0.65 - 1);

//四舍五入就可以, 可以无视example

builder.append(String.format("%.2f", profit));

System.out.println(builder);

}

private static Bet getBet() throws IOException {

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

int max_index = 0;

double max_bet = -1.0;

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

double v = Double.valueOf(split[i]);

if (v > max_bet) {

max_index = i;

max_bet = v;

}

return new Bet(max_index, max_bet);

}

[Java] 1010. Radix (25)-PAT甲级

1010. Radix (25)
Given a pair of positive integers, for example, 6 and 110, can this equation 6 = 110 be true? The answer is “yes”, if 6 is a decimal number and 110 is a binary number.

Now for any pair of positive integers N1 and N2, your task is to find the radix of one number while that of the other is given.

Input Specification:

Each input file contains one test case. Each case occupies a line which contains 4 positive integers:
N1 N2 tag radix
Here N1 and N2 each has no more than 10 digits. A digit is less than its radix and is chosen from the set {0-9, a-z} where 0-9 represent the decimal numbers 0-9, and a-z represent the decimal numbers 10-35. The last number “radix” is the radix of N1 if “tag” is 1, or of N2 if “tag” is 2.

Output Specification:

For each test case, print in one line the radix of the other number so that the equation N1 = N2 is true. If the equation is impossible, print “Impossible”. If the solution is not unique, output the smallest possible radix.

Sample Input 1:
6 110 1 10
Sample Output 1:
2
Sample Input 2:
1 ab 1 2
Sample Output 2:
Impossible

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 static String binarySearch(final String value, final BigInteger expect) {
        //重点在于最大值和最小值的界定 下界大于 所有位中最大值 考虑2 2 1 10 这个case
        BigInteger start = BigInteger.valueOf(maxBitValue(value) + 1);
        //上界不小于下界,不大于expect 考虑200000 1 1 10 这个case
        BigInteger end = expect.compareTo(start) < 0 ? start : expect;

        BigInteger result_radix = null;
        while (end.compareTo(start) >= 0) {
            BigInteger middle = start.add(end).divide(BigInteger.valueOf(2));
            BigInteger ten_value = convert2ten(value, middle);
            int compare = ten_value.compareTo(expect);
            if (compare >= 0) {
                if (compare == 0 && (result_radix == null || middle.compareTo(result_radix) < 0)) {
                    result_radix = middle;
                }
                end = middle.subtract(BigInteger.valueOf(1));
            } else {
                start = middle.add(BigInteger.valueOf(1));
            }
        }
        return result_radix == null ? "Impossible" : result_radix + "";
    }

    private static BigInteger convert2ten(String value, BigInteger radix) {
        char[] chars = value.toCharArray();
        BigInteger sum = BigInteger.ZERO;
        for (char aChar : chars) {
            int v = char2int(aChar);
            if (radix.compareTo(BigInteger.valueOf(v)) < 0) {
                return BigInteger.valueOf(Long.MAX_VALUE);
            }
            sum = sum.multiply(radix).add(BigInteger.valueOf(v));
        }
        return sum;
    }

    private static int maxBitValue(String value) {
        int max = 0;
        for (char c : value.toCharArray()) {
            int i = char2int(c);
            if (i > max) max = i;
        }
        return max;
    }

    private static int char2int(char c) {
        int ret = c - 48;
        return ret < 10 ? ret : ret - 39;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] split = reader.readLine().split(" ");
        String v1 = split[0], v2 = split[1];
        String know_v = v1, unknow_v = v2;
        BigInteger know_radix = BigInteger.valueOf(Integer.valueOf(split[3]));
        if ("2".equals(split[2])) {
            know_v = v2;
            unknow_v = v1;
        }
        //期望值转化为十进制 相当于把输入转化为 N1 N2 1 10
        BigInteger expect = convert2ten(know_v, know_radix);
        String s = binarySearch(unknow_v, expect);
        System.out.println(s);
    }
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.math.BigInteger;

public class Main {

private static String binarySearch(final String value, final BigInteger expect) {

//重点在于最大值和最小值的界定下界大于所有位中最大值考虑2 2 1 10 这个case

BigInteger start = BigInteger.valueOf(maxBitValue(value) + 1);

//上界不小于下界,不大于expect 考虑200000 1 1 10 这个case

BigInteger end = expect.compareTo(start) < 0 ? start : expect;

BigInteger result_radix = null;

while (end.compareTo(start) >= 0) {

BigInteger middle = start.add(end).divide(BigInteger.valueOf(2));

BigInteger ten_value = convert2ten(value, middle);

int compare = ten_value.compareTo(expect);

if (compare >= 0) {

if (compare == 0 && (result_radix == null || middle.compareTo(result_radix) < 0)) {

result_radix = middle;

}

end = middle.subtract(BigInteger.valueOf(1));

} else {

start = middle.add(BigInteger.valueOf(1));

}

return result_radix == null ? "Impossible" : result_radix + "";

}

private static BigInteger convert2ten(String value, BigInteger radix) {

char[] chars = value.toCharArray();

BigInteger sum = BigInteger.ZERO;

for (char aChar : chars) {

int v = char2int(aChar);

if (radix.compareTo(BigInteger.valueOf(v)) < 0) {

return BigInteger.valueOf(Long.MAX_VALUE);

}

sum = sum.multiply(radix).add(BigInteger.valueOf(v));

}

return sum;

}

private static int maxBitValue(String value) {

int max = 0;

for (char c : value.toCharArray()) {

int i = char2int(c);

if (i > max) max = i;

}

return max;

}

private static int char2int(char c) {

int ret = c - 48;

return ret < 10 ? ret : ret - 39;

}

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

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

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

String v1 = split[0], v2 = split[1];

String know_v = v1, unknow_v = v2;

BigInteger know_radix = BigInteger.valueOf(Integer.valueOf(split[3]));

if ("2".equals(split[2])) {

know_v = v2;

unknow_v = v1;

}

//期望值转化为十进制相当于把输入转化为 N1 N2 1 10

BigInteger expect = convert2ten(know_v, know_radix);

String s = binarySearch(unknow_v, expect);

System.out.println(s);

}