二十分（java更新至2021年）

L1-002 打印沙漏 (20 分)

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

************
*****

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。
给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。
输入格式:
输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。
输出格式:
首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。
输入样例:

19 *

输出样例:

************
*****
2

思路：

计算上半部分或下半部分层数，空格数为层数递减或递加，字符数为二倍层数减一

代码：

import java.util.Scanner;public class Main{static Scanner scanner = new Scanner(System.in);static int num = 1, n = scanner.nextInt(), x = GetNum(n);static String ch = scanner.next();public static void main(String[] args) {// write your code herefor (int i = x; i >= 1; i--)printLine(i);for (int i = 2; i <= x; i++)printLine(i);System.out.println(n - num);}private static void printLine(int i) {for (int j = 0; j < x - i; j++)System.out.print(" ");for (int j = 0; j < 2 * i - 1; j++)System.out.print(ch);System.out.println();}private static int GetNum(int nextInt) {int index = 0;for (int i = 3; ; i += 2)if (num > nextInt) {num -= (i - 2) * 2;break;} else {index++;num += i * 2;}return index;}
}

L1-006 连续因子 (20 分)

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。
输入格式：
输入在一行中给出一个正整数 N（1<N<231）。
输出格式：
首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按因子1因子2……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。
输入样例：

输出样例：

3
5*6*7

思路：

从2开始每个循环加一往上乘，当大于输入的数时停止，在此期间记录起始点和长度，最终输出最长连续因数

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);long n = scanner.nextLong();long start = 0, len = 0;long sum = 0;for (int i = 2; i < Math.sqrt(n); i++) {sum = 1;for (int j = i; sum * i <= n; j++) {sum *= j;if (n % sum == 0 && j - i + 1 > len) {start = i;len = j - i + 1;}}}if (start == 0) {start = n;len = 1;}System.out.println(len);for (int i = 0; i < len - 1; i++) {System.out.print(start + i + "*");}System.out.print(start + len - 1);}
}

L1-009 N个数求和 (20 分)

本题的要求很简单，就是求N个数字的和。麻烦的是，这些数字是以有理数
分子/分母的形式给出的，你输出的和也必须是有理数的形式。
输入格式：
输入第一行给出一个正整数N（≤100）。随后一行按格式a1/b1 a2/b2 …给出N个有理数。题目保证所有分子和分母都在长整型范围内。另外，负数的符号一定出现在分子前面。

输出格式：
输出上述数字和的最简形式 —— 即将结果写成整数部分分数部分，其中分数部分写成分子/分母，要求分子小于分母，且它们没有公因子。如果结果的整数部分为0，则只输出分数部分。
输入样例1：

5
2/5 4/15 1/30 -2/60 8/3

输出样例1：

3 1/3

输入样例2：

2
4/3 2/3

输出样例2：

输入样例3：

3
1/3 -1/6 1/8

输出样例3：

7/24

思路：

每次计算一次最大公约数，再计算出每次最大公倍数作为分母，分子乘相应倍数相加，java的Scanner会超时

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));long n = Long.parseLong(reader.readLine()), countup = 0, countdown = 0;String[] all = reader.readLine().split(" ");for (int i = 0; i < n; i++) {long up = Long.parseLong(all[i].substring(0, all[i].indexOf("/")));long down = Long.parseLong(all[i].substring(all[i].indexOf("/") + 1));if (i == 0) {countdown = down;countup = up;} else {long minMultiple = countdown*down/MaxMultiple(countdown,down);countup = countup * (minMultiple / countdown) + up * (minMultiple / down);countdown = minMultiple;}}if (countup == 0)System.out.println("0");if (Math.abs(countup) >= countdown)System.out.print(countup / countdown);if (Math.abs(countup) % countdown != 0) {if (Math.abs(countup) > countdown)System.out.print(" ");long maxMultiple = MaxMultiple(countup % countdown, countdown);System.out.println((countup % countdown) / maxMultiple + "/" + countdown / maxMultiple);}}private static long MaxMultiple(long countup, long countdown) {return countdown == 0 ? countup : MaxMultiple(countdown, countup%countdown);}}

L1-011 A-B (20 分)

本题要求你计算A−B。不过麻烦的是，A和B都是字符串 —— 即从字符串A中把字符串B所包含的字符全删掉，剩下的字符组成的就是字符串A−B。
输入格式：
输入在2行中先后给出字符串A和B。两字符串的长度都不超过104，并且保证每个字符串都是由可见的ASCII码和空白字符组成，最后以换行符结束。
输出格式：
在一行中打印出A−B的结果字符串。
输入样例：

I love GPLT!  It's a fun game!
aeiou

输入样例：

I lv GPLT!  It's  fn gm!

思路：

循环遇到排除项不输出，其余正常输出，java可用replaceAll和正则表达式直接替换成空输出

代码：

import java.io.*;public class Main{public static void main(String[] args) throws IOException {// write your code hereSystem.out.println(new BufferedReader(new InputStreamReader(System.in)).readLine().replaceAll("["+reader.readLine()+"]",""));}
}

L1-020 帅到没朋友 (20 分)

当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。本题就要求你找出那些帅到没有朋友的人。
输入格式：
输入第一行给出一个正整数N（≤100），是已知朋友圈的个数；随后N行，每行首先给出一个正整数K（≤1000），为朋友圈中的人数，然后列出一个朋友圈内的所有人——为方便起见，每人对应一个ID号，为5位数字（从00000到99999），ID间以空格分隔；之后给出一个正整数M（≤10000），为待查询的人数；随后一行中列出M个待查询的ID，以空格分隔。
注意：没有朋友的人可以是根本没安装“朋友圈”，也可以是只有自己一个人在朋友圈的人。虽然有个别自恋狂会自己把自己反复加进朋友圈，但题目保证所有K超过1的朋友圈里都至少有2个不同的人。
输出格式：
按输入的顺序输出那些帅到没朋友的人。ID间用1个空格分隔，行的首尾不得有多余空格。如果没有人太帅，则输出No one is handsome。
注意：同一个人可以被查询多次，但只输出一次。
输入样例1：

3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
8
55555 44444 10000 88888 22222 11111 23333 88888

输出样例1：

10000 88888 23333

输入样例2：

3
3 11111 22222 55555
2 33333 44444
4 55555 66666 99999 77777
4
55555 44444 22222 11111

输出样例2：

No one is handsome

思路：

开辟标记数组，出现过的标记为已出现，当一行只有一条数据时不进行操作

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));boolean[] flag = new boolean[100001];boolean F = true;int n = Integer.parseInt(reader.readLine());for (int i = 0; i < n; i++) {String[] str = reader.readLine().split(" ");int m = Integer.parseInt(str[0]);if (m != 1)for (int j = 1; j <= m; j++)flag[Integer.parseInt(str[j])] = true;}n = Integer.parseInt(reader.readLine());String[] str = reader.readLine().split(" ");for (int i = 0; i < n; i++) {if (!flag[Integer.parseInt(str[i])]) {if (F == false)System.out.print(" ");System.out.printf(str[i]);flag[Integer.parseInt(str[i])] = true;F = false;}}if (F)System.out.println("No one is handsome");}
}

L1-023 输出GPLT (20 分)

给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT…这样的顺序输出，并忽略其它字符。当然，四种字符（不区分大小写）的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按GPLT的顺序打印，直到所有字符都被输出。
输入格式：
输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。
输出格式：
在一行中按题目要求输出排序后的字符串。题目保证输出非空。
输入样例：

pcTclnGloRgLrtLhgljkLhGFauPewSKgt

输出样例：

GPLTGPLTGLTGLGLL

思路：

计算出现此数，循环数出，java会超时，学艺不精，暂时无法解决

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereString str = new BufferedReader(new InputStreamReader(System.in)).readLine().toUpperCase().replaceAll("[^GPLT]", "");while (0 < str.length()) {str = PrintChar(str, "G");str = PrintChar(str, "P");str = PrintChar(str, "L");str = PrintChar(str, "T");}}private static String PrintChar(String str, String string) {if (str.indexOf(string) != -1) {System.out.print(string);str = str.replaceFirst(string, "");}return str;}
}

L1-027 出租 (20 分)

下面是新浪微博上曾经很火的一张图：一时间网上一片求救声，急问这个怎么破。其实这段代码很简单，index数组就是arr数组的下标，index[0]=2对应 arr[2]=1，index[1]=0 对应 arr[0]=8，index[2]=3 对应 arr[3]=0，以此类推…… 很容易得到电话号码是18013820100。
本题要求你编写一个程序，为任何一个电话号码生成这段代码 —— 事实上，只要生成最前面两行就可以了，后面内容是不变的。
输入格式：
输入在一行中给出一个由11位数字组成的手机号码。
输出格式：
为输入的号码生成代码的前两行，其中arr中的数字必须按递减顺序给出。
输入样例：

18013820100

输出样例：

int[] arr = new int[]{8,3,2,1,0};
int[] index = new int[]{3,0,4,3,1,0,2,4,3,4,4};

思路：

从大到下记录出现的数字保存在数组，在输出对应下标

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereString s = new Scanner(System.in).nextLine(), arr = "", index = "";for (char i = '9'; i >= '0'; i--)if (s.indexOf(i) != -1)arr = arr + i + ",";arr = "int[] arr = new int[]{" + arr.substring(0, arr.length() - 1) + "};\n";for (int i = 0; i < s.length(); i++)index = index + (arr.indexOf(s.charAt(i)) / 2 - 11) + ",";index = "int[] index = new int[]{" + index.substring(0, index.length() - 1) + "};";System.out.println(arr + index);}
}

L1-032 Left-pad (20 分)

根据新浪微博上的消息，有一位开发者不满NPM（Node Package Manager）的做法，收回了自己的开源代码，其中包括一个叫left-pad的模块，就是这个模块把javascript里面的React/Babel干瘫痪了。这是个什么样的模块？就是在字符串前填充一些东西到一定的长度。例如用去填充字符串GPLT，使之长度为10，调用left-pad的结果就应该是*****GPLT。Node社区曾经对left-pad紧急发布了一个替代，被严重吐槽。下面就请你来实现一下这个模块。
输入格式：
输入在第一行给出一个正整数N（≤104）和一个字符，分别是填充结果字符串的长度和用于填充的字符，中间以1个空格分开。第二行给出原始的非空字符串，以回车结束。
输出格式：
在一行中输出结果字符串。
输入样例1：

15 _
I love GPLT

输出样例1：

____I love GPLT

输入样例2：

4 *
this is a sample for cut

输出样例2：

cut

思路：

长度大于等于题目所给数据时，截取后面所给数据长度，小于时前面补符号

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scan = new Scanner(System.in);int x=scan.nextInt();String sym=scan.next();scan.nextLine();String str=scan.nextLine();if (str.length()>=x)System.out.println(str.substring(str.length()-x));else {for (int i = 0; i < x - str.length(); i++)System.out.print(sym);System.out.println(str);}}
}

L1-034 点赞 (20 分)

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。本题就要求你写个程序，通过统计一个人点赞的纪录，分析这个人的特性。
输入格式：
输入在第一行给出一个正整数N（≤1000），是该用户点赞的博文数量。随后N行，每行给出一篇被其点赞的博文的特性描述，格式为“K F1 ⋯FK ”，其中1≤K≤10，Fi（i=1,⋯,K）是特性标签的编号，我们将所有特性标签从1到1000编号。数字间以空格分隔。
输出格式：
统计所有被点赞的博文中最常出现的那个特性标签，在一行中输出它的编号和出现次数，数字间隔1个空格。如果有并列，则输出编号最大的那个。
输入样例：

4
3 889 233 2
5 100 3 233 2 73
4 3 73 889 2
2 233 123

输出样例：

233 3

思路：

开辟数组牺牲空间换取效率，输出最大次数值与次数，如有相同次数输出编号大的

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereint[] ints = new int[1001];BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(reader.readLine());for (int i = 0; i < n; i++) {String[] num = reader.readLine().split(" ");for (int j = 1; j < num.length; j++)ints[Integer.parseInt(num[j])]++;}int max=0,index=0;for (int i = 0; i < 1001; i++)if (max<=ints[i]){max=ints[i];index=i;}System.out.println(index+" "+max);}
}

L1-039 古风排版 (20 分)

中国的古人写文字，是从右向左竖向排版的。本题就请你编写程序，把一段文字按古风排版。
输入格式：
输入在第一行给出一个正整数N（<100），是每一列的字符数。第二行给出一个长度不超过1000的非空字符串，以回车结束。
输出格式：
按古风格式排版给定的字符串，每列N个字符（除了最后一列可能不足N个）。
输入样例：

4
This is a test case

输出样例：

asa T
st ih
e tsice s

思路：

以所给数字第一个大于字符串长度的倍数为准补空格，之后从后向前取字符输出

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);int x = scanner.nextInt();scanner.nextLine();String str = scanner.nextLine();while (str.length() % x != 0)str += " ";for (int i = x; i >= 1; i--) {for (int j = str.length() - i; j >= 0; j -= x)System.out.print(str.charAt(j));System.out.println();}}
}

L1-043 阅览室 (20 分)

天梯图书阅览室请你编写一个简单的图书借阅统计程序。当读者借书时，管理员输入书号并按下S键，程序开始计时；当读者还书时，管理员输入书号并按下E键，程序结束计时。书号为不超过1000的正整数。当管理员将0作为书号输入时，表示一天工作结束，你的程序应输出当天的读者借书次数和平均阅读时间。
注意：由于线路偶尔会有故障，可能出现不完整的纪录，即只有S没有E，或者只有E没有S的纪录，系统应能自动忽略这种无效纪录。另外，题目保证书号是书的唯一标识，同一本书在任何时间区间内只可能被一位读者借阅。
输入格式：
输入在第一行给出一个正整数N（≤10），随后给出N天的纪录。每天的纪录由若干次借阅操作组成，每次操作占一行，格式为：
书号（[1, 1000]内的整数）键值（S或E）发生时间（hh:mm，其中hh是[0,23]内的整数，mm是[0, 59]内整数）
每一天的纪录保证按时间递增的顺序给出。
输出格式：
对每天的纪录，在一行中输出当天的读者借书次数和平均阅读时间（以分钟为单位的精确到个位的整数时间）。
输入样例：

输出样例：

2 196
0 0
1 60

思路：

一次借书，多次还书以第一次还书为准；多次借书，一次还书以最后一次借书为准；还需注意样例中有时间为00:00，并且保证同一本书在上一次借还完成后还可以再次借还

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(reader.readLine()), sum = 0, count = 0;for (int i = 0; i < n; i++) {sum = 0;count = 0;int[] ints = new int[1001];boolean[] booleans = new boolean[1001];while (true) {String[] str = reader.readLine().split(" ");if (Integer.parseInt(str[0]) == 0)break;if (str[1].equals("S")) {ints[Integer.parseInt(str[0])] = Integer.parseInt(str[2].substring(0, 2)) * 60 + Integer.parseInt(str[2].substring(3));booleans[Integer.parseInt(str[0])] = true;} else if (booleans[Integer.parseInt(str[0])] && str[1].equals("E")) {sum += Integer.parseInt(str[2].substring(0, 2)) * 60 + Integer.parseInt(str[2].substring(3)) - ints[Integer.parseInt(str[0])];count++;booleans[Integer.parseInt(str[0])] = false;}}if (count != 0)System.out.println(count + " " + (int) ((float) sum / count + 0.5));elseSystem.out.println("0 0");}}
}

L1-046 整除光棍 (20 分)

这里所谓的“光棍”，并不是指单身汪啦~ 说的是全部由1组成的数字，比如1、11、111、1111等。传说任何一个光棍都能被一个不以5结尾的奇数整除。比如，111111就可以被13整除。现在，你的程序要读入一个整数x，这个整数一定是奇数并且不以5结尾。然后，经过计算，输出两个数字：第一个数字s，表示x乘以s是一个光棍，第二个数字n是这个光棍的位数。这样的解当然不是唯一的,题目要求你输出最小的解。
提示：一个显然的办法是逐渐增加光棍的位数，直到可以整除x为止。但难点在于，s可能是个非常大的数 —— 比如，程序输入31，那么就输出3584229390681和15，因为31乘以3584229390681的结果是111111111111111，一共15个1。
输入格式：
输入在一行中给出一个不以5结尾的正奇数x（<1000）。
输出格式：
在一行中输出相应的最小的s和n，其间以1个空格分隔。
输入样例：

输出样例：

3584229390681 15

思路：

取模乘十加一，有效减少数字位数，原理为竖式除法

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereint n = new Scanner(System.in).nextInt(), sum = 1, count = 1;while (sum < n) {sum = sum * 10 + 1;count++;}while (sum % n != 0) {System.out.print(sum / n);sum %= n;sum = sum * 10 + 1;count++;}System.out.println(sum / n + " " + count);}
}

L1-049 天梯赛座位分配 (20 分)

天梯赛每年有大量参赛队员，要保证同一所学校的所有队员都不能相邻，分配座位就成为一件比较麻烦的事情。为此我们制定如下策略：假设某赛场有 N 所学校参赛，第 i 所学校有 M[i] 支队伍，每队 10 位参赛选手。令每校选手排成一列纵队，第 i+1 队的选手排在第 i 队选手之后。从第 1 所学校开始，各校的第 1 位队员顺次入座，然后是各校的第 2 位队员…… 以此类推。如果最后只剩下 1 所学校的队伍还没有分配座位，则需要安排他们的队员隔位就坐。本题就要求你编写程序，自动为各校生成队员的座位号，从 1 开始编号。
输入格式：
输入在一行中给出参赛的高校数 N （不超过100的正整数）；第二行给出 N 个不超过10的正整数，其中第 i 个数对应第 i 所高校的参赛队伍数，数字间以空格分隔。
输出格式：
从第 1 所高校的第 1 支队伍开始，顺次输出队员的座位号。每队占一行，座位号间以 1 个空格分隔，行首尾不得有多余空格。另外，每所高校的第一行按“#X”输出该校的编号X，从 1 开始。
输入样例：

3
3 4 2

输出样例：

#1
1 4 7 10 13 16 19 22 25 28
31 34 37 40 43 46 49 52 55 58
61 63 65 67 69 71 73 75 77 79
#2
2 5 8 11 14 17 20 23 26 29
32 35 38 41 44 47 50 53 56 59
62 64 66 68 70 72 74 76 78 80
82 84 86 88 90 92 94 96 98 100
#3
3 6 9 12 15 18 21 24 27 30
33 36 39 42 45 48 51 54 57 60

思路：

测试点2为一所学校参加，按照学校划分，先存在数组，之后格式化输出

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(reader.readLine()), m = n;String ch[] = reader.readLine().split(" ");int[] ints = new int[n], temp = new int[n];for (int i = 0; i < n; i++) {temp[i] = ints[i] = Integer.parseInt(ch[i]);temp[i] *= 10;}Arrays.sort(temp);int start = 0, step = 1, x = temp[temp.length - 1];if (n == 1)start = -1;int[][] arr = new int[n][x];for (int i = 0; i < x; i++)for (int j = 0; j < n; j++) {if (m < 2)step = 2;if (ints[j] * 10 > i) {start += step;arr[j][i] = start;} else if (temp[j] != 0) {temp[j] = 0;m--;}}for (int i = 0; i < n; i++) {System.out.println("#" + (i + 1));for (int j = 0; j < ints[i] * 10; j++) {System.out.print(arr[i][j]);if ((j + 1) % 10 == 0)System.out.println();elseSystem.out.print(" ");}}}
}

L1-056 猜数字 (20 分)

一群人坐在一起，每人猜一个 100 以内的数，谁的数字最接近大家平均数的一半就赢。本题就要求你找出其中的赢家。
输入格式：
输入在第一行给出一个正整数N（≤104）。随后 N 行，每行给出一个玩家的名字（由不超过8个英文字母组成的字符串）和其猜的正整数（≤ 100）。
输出格式：
在一行中顺序输出：大家平均数的一半（只输出整数部分）、赢家的名字，其间以空格分隔。题目保证赢家是唯一的。
输入样例：

7
Bob 35
Amy 28
James 98
Alice 11
Jack 45
Smith 33
Chris 62

输出样例：

22 Amy

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(reader.readLine()), count = 0, index = 0, min = 10000;String[] str = new String[n];int[] ints = new int[n];for (int i = 0; i < n; i++) {String[] ch = reader.readLine().split(" ");str[i] = ch[0];ints[i] = Integer.parseInt(ch[1]);count += ints[i];}int aver = count / n / 2;System.out.print(aver + " ");for (int i = 0; i < n; i++) {int abs = Math.abs(aver - ints[i]);if (min > abs) {index = i;min = abs;}}System.out.println(str[index]);}
}

L1-059 敲笨钟 (20 分)

微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。为了增加敲钟的趣味性，还会糟改几句古诗词。其糟改的方法为：去网上搜寻压“ong”韵的古诗词，把句尾的三个字换成“敲笨钟”。例如唐代诗人李贺有名句曰：“寻章摘句老雕虫，晓月当帘挂玉弓”，其中“虫”（chong）和“弓”（gong）都压了“ong”韵。于是这句诗就被糟改为“寻章摘句老雕虫，晓月当帘敲笨钟”。
现在给你一大堆古诗词句，要求你写个程序自动将压“ong”韵的句子糟改成“敲笨钟”。
输入格式：
输入首先在第一行给出一个不超过 20 的正整数 N。随后 N 行，每行用汉语拼音给出一句古诗词，分上下两半句，用逗号 , 分隔，句号 . 结尾。相邻两字的拼音之间用一个空格分隔。题目保证每个字的拼音不超过 6 个字符，每行字符的总长度不超过 100，并且下半句诗至少有 3 个字。
输出格式：
对每一行诗句，判断其是否压“ong”韵。即上下两句末尾的字都是“ong”结尾。如果是压此韵的，就按题面方法糟改之后输出，输出格式同输入；否则输出 Skipped，即跳过此句。
输入样例：

5
xun zhang zhai ju lao diao chong, xiao yue dang lian gua yu gong.
tian sheng wo cai bi you yong, qian jin san jin huan fu lai.
xue zhui rou zhi leng wei rong, an xiao chen jing shu wei long.
zuo ye xing chen zuo ye feng, hua lou xi pan gui tang dong.
ren xian gui hua luo, ye jing chun shan kong.

输出样例：

xun zhang zhai ju lao diao chong, xiao yue dang lian qiao ben zhong.
Skipped
xue zhui rou zhi leng wei rong, an xiao chen jing qiao ben zhong.
Skipped
Skipped

思路：

检查“,”和“.”前是否为“ong”，若是就输出倒数第三个空格前的字符串，最后补上qiao ben zhong，

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(reader.readLine());for (int i = 0; i < n; i++) {String str = reader.readLine();if (str.contains("ong,") && str.contains("ong.")) {String[] s = str.split(" ");for (int j = 0; j < s.length - 3; j++) {System.out.print(s[j] + " ");}System.out.println("qiao ben zhong.");} elseSystem.out.println("Skipped");}}
}

L1-064 估值一亿的AI核心代码 (20 分)

以上图片来自新浪微博。
本题要求你实现一个稍微更值钱一点的 AI 英文问答程序，规则是：

无论用户说什么，首先把对方说的话在一行中原样打印出来；
消除原文中多余空格：把相邻单词间的多个空格换成 1 个空格，把行首尾的空格全部删掉，把标点符号前面的空格删掉；
把原文中所有大写英文字母变成小写，除了 I；
把原文中所有独立的 can you、could you 对应地换成 I can、I could——
这里“独立”是指被空格或标点符号分隔开的单词；
把原文中所有独立的 I 和 me 换成 you；
把原文中所有的问号 ? 换成惊叹号 !；
在一行中输出替换后的句子作为 AI 的回答。

输入格式：
输入首先在第一行给出不超过 10 的正整数 N，随后 N 行，每行给出一句不超过 1000 个字符的、以回车结尾的用户的对话，对话为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。
输出格式：
按题面要求输出，每个 AI 的回答前要加上 AI: 和一个空格。
输入样例：

6
Hello ?Good to chat   with you
can   you speak Chinese?
Really?
Could you show me 5
What Is this prime? I,don 't know

输出样例：

Hello ?
AI: hello!Good to chat   with you
AI: good to chat with you
can   you speak Chinese?
AI: I can speak chinese!
Really?
AI: really!
Could you show me 5
AI: I could show you 5
What Is this prime? I,don 't know
AI: what Is this prime! you,don't know

思路：

先将字符串整体处理成标准格式，在逐步替换
1、消除空格
2、大写字母变小写，I不用转
3、问号 ? 换成惊叹号 !
4、 can you、could you 暂时换成除I外的大写字母或单词，因为can you、could you和I、me是单独替换
5、 I、me换成you
6、将第四步换的单词换成I can、I could

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main {public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(reader.readLine());for (int i = 0; i < n; i++) {String str = reader.readLine();System.out.println(str);str = str.replaceAll(" +", " ").replaceAll(" (?=\\W)", "").trim()//去空格.replaceAll("\\?", "!")//?->!.replaceAll("I", "a_a_a_a")//暂时替换单词中的I.toLowerCase()//转小写.replaceAll("a_a_a_a", "I")//换回暂时替换单词中的I.replaceAll("\\bcan you\\b", "CAN")//can you暂时替换.replaceAll("\\bcould you\\b", "COULD")//could you暂时替换.replaceAll("\\b(I|me)\\b", "you")//I,me->you.replaceAll("CAN", "I can")//换回I can.replaceAll("COULD", "I could");//换回I couldSystem.out.println("AI: " + str);}}
}

L1-071 前世档案 (20 分)

网络世界中时常会遇到这类滑稽的算命小程序，实现原理很简单，随便设计几个问题，根据玩家对每个问题的回答选择一条判断树中的路径（如下图所示），结论就是路径终点对应的那个结点。

现在我们把结论从左到右顺序编号，编号从 1 开始。这里假设回答都是简单的“是”或“否”，又假设回答“是”对应向左的路径，回答“否”对应向右的路径。给定玩家的一系列回答，请你返回其得到的结论的编号。
输入格式：
输第一行给出两个正整数：N（≤30）为玩家做一次测试要回答的问题数量；M（≤100）为玩家人数。

随后 M 行，每行顺次给出玩家的 N 个回答。这里用 y 代表“是”，用 n 代表“否”。
输出格式：
对每个玩家，在一行中输出其对应的结论的编号。
输入样例：

3 4
yny
nyy
nyn
yyn

输出样例：

思路：

出现y不用处理，出现n时则给和加上2n-j,(n为总行数，j为当前行数)

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);int x = scanner.nextInt(), n = scanner.nextInt();for (int i = 0; i < n; i++) {int sum = 1;char[] ques = scanner.next().toCharArray();for (int j = 1; j <= x; j++) {if (ques[j - 1] == 'n')sum += Math.pow(2, x - j);}System.out.println(sum);}}
}

L1-072 刮刮彩票 (20 分)

“刮刮彩票”是一款网络游戏里面的一个小游戏。如图所示：

每次游戏玩家会拿到一张彩票，上面会有 9 个数字，分别为数字 1 到数字 9，数字各不重复，并以 3×3 的“九宫格”形式排布在彩票上。
在游戏开始时能看见一个位置上的数字，其他位置上的数字均不可见。你可以选择三个位置的数字刮开，这样玩家就能看见四个位置上的数字了。最后玩家再从 3 横、3 竖、2 斜共 8 个方向中挑选一个方向，方向上三个数字的和可根据下列表格进行兑奖，获得对应数额的金币。

数字合计	获得金币	数字合计	获得金币
6	10,000	16	72
7	36	17	180
8	720	18	119
9	360	19	36
10	80	20	306
11	252	21	1,080
12	108	22	144
13	72	23	1,800
14	54	24	3,600
15	180

现在请你写出一个模拟程序，模拟玩家的游戏过程。
输入格式：
输入第一部分给出一张合法的彩票，即用 3 行 3 列给出 0 至 9 的数字。0 表示的是这个位置上的数字初始时就能看见了，而不是彩票上的数字为 0。
第二部给出玩家刮开的三个位置，分为三行，每行按格式 x y 给出玩家刮开的位置的行号和列号（题目中定义左上角的位置为第 1 行、第 1 列。）。数据保证玩家不会重复刮开已刮开的数字。
最后一部分给出玩家选择的方向，即一个整数： 1 至 3 表示选择横向的第一行、第二行、第三行，4 至 6 表示纵向的第一列、第二列、第三列，7、8分别表示左上到右下的主对角线和右上到左下的副对角线。
输出格式：
对于每一个刮开的操作，在一行中输出玩家能看到的数字。最后对于选择的方向，在一行中输出玩家获得的金币数量。
输入样例：

输出样例：

思路：

按照题目思路3*3矩阵存储

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {Scanner scan = new Scanner(System.in);int[][] ints = new int[3][3];int[] flag = new int[10];int count = 0, mi = 0, mj = 0;for (int i = 0; i < 3; i++)for (int j = 0; j < 3; j++) {ints[i][j] = scan.nextInt();count += ints[i][j];if (ints[i][j] == 0) {mi = i;mj = j;}}ints[mi][mj] = 45 - count;for (int i = 0; i < 3; i++) {mi = scan.nextInt();mj = scan.nextInt();System.out.println(ints[mi - 1][mj - 1]);}int select = scan.nextInt();if (select == 1)count = ints[0][0] + ints[0][1] + ints[0][2];else if (select == 2)count = ints[1][0] + ints[1][1] + ints[1][2];else if (select == 3)count = ints[2][0] + ints[2][1] + ints[2][2];else if (select == 4)count = ints[0][0] + ints[1][0] + ints[2][0];else if (select == 5)count = ints[0][1] + ints[1][1] + ints[0][2];else if (select == 6)count = ints[0][2] + ints[1][2] + ints[2][2];else if (select == 7)count = ints[0][0] + ints[1][1] + ints[2][2];elsecount = ints[0][2] + ints[1][1] + ints[2][0];PrintNum(count);}private static void PrintNum(int count) {int money[][] = {{6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}, {10000, 36, 720, 360, 80, 252, 108, 72, 54, 180, 72, 180, 119, 36, 306, 1080, 144, 1800, 3600}};for (int i = 0; i < 19; i++)if (count == money[0][i]) {System.out.println(money[1][i]);System.exit(0);}}
}

L1-079 天梯赛的善良 (20 分)

天梯赛是个善良的比赛。善良的命题组希望将题目难度控制在一个范围内，使得每个参赛的学生都有能做出来的题目，并且最厉害的学生也要非常努力才有可能得到高分。

于是命题组首先将编程能力划分成了 106 个等级（太疯狂了，这是假的），然后调查了每个参赛学生的编程能力。现在请你写个程序找出所有参赛学生的最小和最大能力值，给命题组作为出题的参考。
输入格式：
输入在第一行中给出一个正整数 N（≤2×104），即参赛学生的总数。随后一行给出 N 个不超过 106 的正整数，是参赛学生的能力值。
输出格式：
第一行输出所有参赛学生的最小能力值，以及具有这个能力值的学生人数。第二行输出所有参赛学生的最大能力值，以及具有这个能力值的学生人数。同行数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例：

10
86 75 233 888 666 75 886 888 75 666

输出样例：

75 3
888 2

代码：

import java.io.*;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader reader = new BufferedReader(new InputStreamReader(System.in));int n=Integer.parseInt(reader.readLine()),max=0,min=1000001,maxI=0,minI=0;String[] s = reader.readLine().split(" ");for (int i = 0; i < n; i++) {int an =Integer.parseInt(s[i]);if (an<min){min=an;minI=1;}else if(an==min)minI++;if (an>max){max=an;maxI=1;}else if(an==max)maxI++;}System.out.printf("%d %d\n%d %d",min,minI,max,maxI);}
}

L1-080 乘法口诀数列 (20 分)

本题要求你从任意给定的两个 1 位数字 a1 和 a2 开始，用乘法口诀生成一个数列 {an}，规则为从 a1 开始顺次进行，每次将当前数字与后面一个数字相乘，将结果贴在数列末尾。如果结果不是 1 位数，则其每一位都应成为数列的一项。
输入格式：
输入在一行中给出 3 个整数，依次为 a1、a2 和 n，满足 0≤a1,a2≤9，0<n≤103。
输出格式：
在一行中输出数列的前 n 项。数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例：

2 3 10

输出样例：

2 3 6 1 8 6 8 4 8 4

样例解释：

数列前 2 项为 2 和 3。从 2 开始，因为 2×3=6，所以第 3 项是 6。因为 3×6=18，所以第 4、5 项分别是
1、8。依次类推…… 最后因为第 6 项有 6×8=48，对应第 10、11 项应该是 4、8。而因为只要求输出前 10 项，所以在输出 4
后结束。

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scan=new Scanner(System.in);String str=scan.next()+scan.next();int n=scan.nextInt();for(int i=0,j=1;;i++,j++){str+=(String.valueOf((str.charAt(i)-'0')*(str.charAt(j)-'0')));if(str.length()>=n)break;}for(int i=0;i<n-1;i++)System.out.print(str.charAt(i)+" ");System.out.print(str.charAt(n-1));}
}