Code – 第143页

PAT 乙级 1039. 到底买不买（20）Java版

小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。

为方便起见，我们用[0-9]、[a-z]、[A-Z]范围内的字符来表示颜色。例如在图1中，第3串是小红想做的珠串；那么第1串可以买，因为包含了全部她想要的珠子，还多了8颗不需要的珠子；第2串不能买，因为没有黑色珠子，并且少了一颗红色的珠子。

图 1输入格式：

每个输入包含1个测试用例。每个测试用例分别在2行中先后给出摊主的珠串和小红想做的珠串，两串都不超过1000个珠子。

输出格式：

如果可以买，则在一行中输出“Yes”以及有多少多余的珠子；如果不可以买，则在一行中输出“No”以及缺了多少珠子。其间以1个空格分隔。

输入样例1：

ppRYYGrrYBR2258
YrR8RrY

1 2	ppRYYGrrYBR2258 YrR8RrY

输出样例1：

Yes 8

Yes 8

输入样例2：

ppRYYGrrYB225
YrR8RrY

1 2	ppRYYGrrYB225 YrR8RrY

输出样例2：

No 2

No 2

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		char[] sales = in.nextLine().toCharArray();
		char[] bought = in.nextLine().toCharArray();
		in.close();

		Arrays.sort(sales);
		Arrays.sort(bought);

		int debt = 0;
		for (int i = 0, j = 0; j < bought.length;) {
			if (i != sales.length) {

				if (sales[i] == bought[j]) {
					i++;
					j++;
				} else if (sales[i] > bought[j]) {
					j++;
					debt++;
				} else {
					// sales[i] < bought[j];
					i++;

					if (i == sales.length) {
						debt += sales.length - i;
					}
				}
			} else {
				debt += bought.length - j;
				break;
			}
		}

		if (debt == 0) {
			System.out.println("Yes " + (sales.length - bought.length));
		} else {
			System.out.println("No " + debt);
		}
	}
}

import java.util.Arrays;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

char[] sales = in.nextLine().toCharArray();

char[] bought = in.nextLine().toCharArray();

in.close();

Arrays.sort(sales);

Arrays.sort(bought);

int debt = 0;

for (int i = 0, j = 0; j < bought.length;) {

if (i != sales.length) {

if (sales[i] == bought[j]) {

i++;

j++;

} else if (sales[i] > bought[j]) {

j++;

debt++;

} else {

// sales[i] < bought[j];

i++;

if (i == sales.length) {

debt += sales.length - i;

}

} else {

debt += bought.length - j;

break;

}

if (debt == 0) {

System.out.println("Yes " + (sales.length - bought.length));

} else {

System.out.println("No " + debt);

}

PAT 乙级 1041. 考试座位号(15) Java版

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

10120150912233 2 4

10120150912119 4 1

10120150912126 1 3

10120150912002 3 2

3 4

输出样例：

10120150912002 2
10120150912119 1

1 2	10120150912002 2 10120150912119 1

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		Student[] students = new Student[n];
		for (int i = 0; i < n; i++) {
			students[i] = new Student(in.next(), in.next(), in.next());
		}
		
		int m = in.nextInt();
		for (int i = 0; i < m; i++) {
			String findTestSite = in.next();
			
			for (int j = 0; j < n; j++) {
				if (students[j].testSite.equals(findTestSite)) {
					System.out.println(students[j].id + " " + students[j].correctSite);
				}
			}
		}
		in.close();
	}

}

class Student {
	String id;
	String testSite;
	String correctSite;
	
	public Student(String id, String testSite, String correctSite) {
		this.id = id;
		this.testSite = testSite;
		this.correctSite = correctSite;
	}
}

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

Student[] students = new Student[n];

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

students[i] = new Student(in.next(), in.next(), in.next());

}

int m = in.nextInt();

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

String findTestSite = in.next();

for (int j = 0; j < n; j++) {

if (students[j].testSite.equals(findTestSite)) {

System.out.println(students[j].id + " " + students[j].correctSite);

}

in.close();

}

class Student {

String id;

String testSite;

String correctSite;

public Student(String id, String testSite, String correctSite) {

this.id = id;

this.testSite = testSite;

this.correctSite = correctSite;

}

对输入方式优化了一下，用Scanner读输入用时太长，改了一下输入方式

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

public class Main {

	public static void main(String[] args) throws IOException{
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(bufferedReader.readLine());
		Student[] students = new Student[n];
		for (int i = 0; i < n; i++) {
			String[] strings = bufferedReader.readLine().split(" ");
			students[i] = new Student(strings[0], strings[1], strings[2]);
		}
		
		int m = Integer.parseInt(bufferedReader.readLine());
		String[] test = bufferedReader.readLine().split(" ");
		for (int i = 0; i < m; i++) {
			String findTestSite = test[i];
			
			for (int j = 0; j < n; j++) {
				if (students[j].testSite.equals(findTestSite)) {
					System.out.println(students[j].id + " " + students[j].correctSite);
				}
			}
		}
		bufferedReader.close();
	}

}

class Student {
	String id;
	String testSite;
	String correctSite;
	
	public Student(String id, String testSite, String correctSite) {
		this.id = id;
		this.testSite = testSite;
		this.correctSite = correctSite;
	}
}

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Main {

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

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

int n = Integer.parseInt(bufferedReader.readLine());

Student[] students = new Student[n];

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

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

students[i] = new Student(strings[0], strings[1], strings[2]);

}

int m = Integer.parseInt(bufferedReader.readLine());

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

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

String findTestSite = test[i];

for (int j = 0; j < n; j++) {

if (students[j].testSite.equals(findTestSite)) {

System.out.println(students[j].id + " " + students[j].correctSite);

}

bufferedReader.close();

}

class Student {

String id;

String testSite;

String correctSite;

public Student(String id, String testSite, String correctSite) {

this.id = id;

this.testSite = testSite;

this.correctSite = correctSite;

}

PAT 乙级 1042. 字符统计(20) Java版

请编写程序，找出一段给定文字中出现最频繁的那个英文字母。

输入格式：

输入在一行中给出一个长度不超过1000的字符串。字符串由ASCII码表中任意可见字符及空格组成，至少包含1个英文字母，以回车结束（回车不算在内）。

输出格式：

在一行中输出出现频率最高的那个英文字母及其出现次数，其间以空格分隔。如果有并列，则输出按字母序最小的那个字母。统计时不区分大小写，输出小写字母。

输入样例：

This is a simple TEST.  There ARE numbers and other symbols 1&amp;2&amp;3...........

1	This is a simple TEST. There ARE numbers and other symbols 1&2&3...........

输出样例：

e 7

e 7

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		// use string to hold the input
		String string = in.nextLine();

		// create a array which length is 26
		int[] array = new int[26];
		for (int i = 0; i < string.length(); i++) {
			char c = string.charAt(i);

			if (c >= 'a' && c <= 'z') {
				array[c - 'a']++;
			} else if (c >= 'A' && c <= 'Z') {
				array[c - 'A']++;
			} else {
				//except character
				//like number, coin sign and other letters.
			}
		}

		in.close();
		
		int maxIndex = 0;
		for (int i = 1; i < array.length; i++) {
			if (array[i] > array[maxIndex]) {
				maxIndex = i;
			}
		}
		
		System.out.println((char)(maxIndex + 'a') + " " + array[maxIndex]);
	}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

// use string to hold the input

String string = in.nextLine();

// create a array which length is 26

int[] array = new int[26];

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

char c = string.charAt(i);

if (c >= 'a' && c <= 'z') {

array[c - 'a']++;

} else if (c >= 'A' && c <= 'Z') {

array[c - 'A']++;

} else {

//except character

//like number, coin sign and other letters.

}

in.close();

int maxIndex = 0;

for (int i = 1; i < array.length; i++) {

if (array[i] > array[maxIndex]) {

maxIndex = i;

}

System.out.println((char)(maxIndex + 'a') + " " + array[maxIndex]);

}

PAT 乙级 1043. 输出PATest(20) Java版

给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按“PATestPATest….”这样的顺序输出，并忽略其它字符。当然，六种字符的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按PATest的顺序打印，直到所有字符都被输出。

输入格式：

输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。

输出格式：

在一行中按题目要求输出排序后的字符串。题目保证输出非空。

输入样例：

redlesPayBestPATTopTeePHPereatitAPPT

1	redlesPayBestPATTopTeePHPereatitAPPT

输出样例：

PATestPATestPTetPTePePee

1	PATestPATestPTetPTePePee

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		String string = in.nextLine();
		in.close();

		List<Character> PList = new ArrayList<>();
		List<Character> AList = new ArrayList<>();
		List<Character> TList = new ArrayList<>();
		List<Character> eList = new ArrayList<>();
		List<Character> sList = new ArrayList<>();
		List<Character> tList = new ArrayList<>();

		for (int i = 0; i < string.length(); i++) {
			switch (string.charAt(i)) {
			case 'P':
				PList.add(string.charAt(i));
				break;
			case 'A':
				AList.add(string.charAt(i));
				break;
			case 'T':
				TList.add(string.charAt(i));
				break;
			case 'e':
				eList.add(string.charAt(i));
				break;
			case 's':
				sList.add(string.charAt(i));
				break;
			case 't':
				tList.add(string.charAt(i));
				break;

			}
		}

		int maxSize = PList.size();
		if (AList.size() > maxSize) {
			maxSize = AList.size();
		}
		if (TList.size() > maxSize) {
			maxSize = TList.size();
		}
		if (eList.size() > maxSize) {
			maxSize = eList.size();
		}
		if (sList.size() > maxSize) {
			maxSize = sList.size();
		}
		if (tList.size() > maxSize) {
			maxSize = tList.size();
		}
		for (int i = 0; i < maxSize; i++) {

			if (i < PList.size()) {
				System.out.print(PList.get(i));
			}
			if (i < AList.size()) {
				System.out.print(AList.get(i));
			}
			if (i < TList.size()) {
				System.out.print(TList.get(i));
			}
			if (i < eList.size()) {
				System.out.print(eList.get(i));
			}
			if (i < sList.size()) {
				System.out.print(sList.get(i));
			}
			if (i < tList.size()) {
				System.out.print(tList.get(i));
			}
		}
	}

}

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

String string = in.nextLine();

in.close();

List<Character> PList = new ArrayList<>();

List<Character> AList = new ArrayList<>();

List<Character> TList = new ArrayList<>();

List<Character> eList = new ArrayList<>();

List<Character> sList = new ArrayList<>();

List<Character> tList = new ArrayList<>();

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

switch (string.charAt(i)) {

case 'P':

PList.add(string.charAt(i));

break;

case 'A':

AList.add(string.charAt(i));

break;

case 'T':

TList.add(string.charAt(i));

break;

case 'e':

eList.add(string.charAt(i));

break;

case 's':

sList.add(string.charAt(i));

break;

case 't':

tList.add(string.charAt(i));

break;

}

int maxSize = PList.size();

if (AList.size() > maxSize) {

maxSize = AList.size();

}

if (TList.size() > maxSize) {

maxSize = TList.size();

}

if (eList.size() > maxSize) {

maxSize = eList.size();

}

if (sList.size() > maxSize) {

maxSize = sList.size();

}

if (tList.size() > maxSize) {

maxSize = tList.size();

}

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

if (i < PList.size()) {

System.out.print(PList.get(i));

}

if (i < AList.size()) {

System.out.print(AList.get(i));

}

if (i < TList.size()) {

System.out.print(TList.get(i));

}

if (i < eList.size()) {

System.out.print(eList.get(i));

}

if (i < sList.size()) {

System.out.print(sList.get(i));

}

if (i < tList.size()) {

System.out.print(tList.get(i));

}

PAT 乙级 1044. 火星数字(20) Java版

火星人是以13进制计数的：

地球人的0被火星人称为tret。
地球人数字1到12的火星文分别为：jan, feb, mar, apr, may, jun, jly, aug, sep, oct, nov, dec。
火星人将进位以后的12个高位数字分别称为：tam, hel, maa, huh, tou, kes, hei, elo, syy, lok, mer, jou。

例如地球人的数字“29”翻译成火星文就是“hel mar”；而火星文“elo nov”对应地球数字“115”。为了方便交流，请你编写程序实现地球和火星数字之间的互译。

输入格式：

输入第一行给出一个正整数N（<100），随后N行，每行给出一个[0, 169)区间内的数字 —— 或者是地球文，或者是火星文。

输出格式：

对应输入的每一行，在一行中输出翻译后的另一种语言的数字。

输入样例：

4
29
5
elo nov
tam

elo nov

tam

输出样例：

hel mar
may
115
13

hel mar

may

115

import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.Map;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);

		// low digit.
		final String[] lowDigit = { "tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov",
				"dec" };

		// high digit.
		final String[] highDigit = { "", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer",
				"jou" };

		// string to number
		Map<String, Integer> map = new HashMap<>();
		for (int i = 0; i < lowDigit.length; i++) {
			map.put(lowDigit[i], i);
		}

		for (int i = 0; i < highDigit.length; i++) {
			map.put(highDigit[i], 13 + i);
		}

		int n = in.nextInt();

		for (int i = 0; i < n; i++) {
			int numInteger = 0;
			String numString = null;

			try {
				numInteger = in.nextInt();
			} catch (InputMismatchException inputMismatchException) {
				numString = in.nextLine();
			} finally {

				if (numString == null) {
					// the input is numbers.
					if (numInteger < 13) {
						System.out.println(lowDigit[numInteger]);
					} else {
						if (numInteger % 13 == 0) {
							System.out.println(highDigit[numInteger / 13]);
						} else {
							System.out.println(highDigit[numInteger / 13] + " " + lowDigit[numInteger % 13]);
						}
					}
				} else {
					// the input is characters.
					String[] tempString = numString.split(" "); // split the
																// input

					// if the length of tempString is 2, it must combine be high
					// and low
					if (tempString.length == 2) {
						System.out.println((map.get(tempString[0]) - 13) * 13 + map.get(tempString[1]));
					} else {
						// maybe high or low

						// map.get(Object) >= 13 is high
						if (map.get(tempString[0]) >= 13) {
							System.out.println((map.get(tempString[0]) - 13) * 13);
						} else {
							System.out.println(map.get(tempString[0]));
						}
					}
				}
			}
		}
		in.close();
	}
}

import java.util.HashMap;

import java.util.InputMismatchException;

import java.util.Map;

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

// low digit.

final String[] lowDigit = { "tret", "jan", "feb", "mar", "apr", "may", "jun", "jly", "aug", "sep", "oct", "nov",

"dec" };

// high digit.

final String[] highDigit = { "", "tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer",

"jou" };

// string to number

Map<String, Integer> map = new HashMap<>();

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

map.put(lowDigit[i], i);

}

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

map.put(highDigit[i], 13 + i);

}

int n = in.nextInt();

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

int numInteger = 0;

String numString = null;

try {

numInteger = in.nextInt();

} catch (InputMismatchException inputMismatchException) {

numString = in.nextLine();

} finally {

if (numString == null) {

// the input is numbers.

if (numInteger < 13) {

System.out.println(lowDigit[numInteger]);

} else {

if (numInteger % 13 == 0) {

System.out.println(highDigit[numInteger / 13]);

} else {

System.out.println(highDigit[numInteger / 13] + " " + lowDigit[numInteger % 13]);

}

} else {

// the input is characters.

String[] tempString = numString.split(" "); // split the

// input

// if the length of tempString is 2, it must combine be high

// and low

if (tempString.length == 2) {

System.out.println((map.get(tempString[0]) - 13) * 13 + map.get(tempString[1]));

} else {

// maybe high or low

// map.get(Object) >= 13 is high

if (map.get(tempString[0]) >= 13) {

System.out.println((map.get(tempString[0]) - 13) * 13);

} else {

System.out.println(map.get(tempString[0]));

}

in.close();

}

PAT 乙级 1046. 划拳(15) Java版

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

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

输入格式：

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

甲喊甲划乙喊乙划

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

输出格式：

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

输入样例：

8 10 9 12

5 10 5 10

3 8 5 12

12 18 1 13

4 16 12 15

输出样例：

1 2

1 2

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int jia = 0, yi = 0;
		for (int i = 0; i < n; i++) {
			int jwhj = in.nextInt();
			int jwhw = in.nextInt();
			int yihj = in.nextInt();
			int yihw = in.nextInt();
			
			int sum = jwhj + yihj;
			if (jwhw == sum && yihw != sum) {
				yi++;
			} else if (jwhw != sum && yihw == sum) {
				jia++;
			}
		}
		in.close();
		
		System.out.println(jia + " " + yi);
	}

}

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

int n = in.nextInt();

int jia = 0, yi = 0;

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

int jwhj = in.nextInt();

int jwhw = in.nextInt();

int yihj = in.nextInt();

int yihw = in.nextInt();

int sum = jwhj + yihj;

if (jwhw == sum && yihw != sum) {

yi++;

} else if (jwhw != sum && yihw == sum) {

jia++;

}

in.close();

System.out.println(jia + " " + yi);

}