十五分（java更新至2021年）

L1-003 个位数统计 (15分)

给定一个 k 位整数 N=dk−110k−1+⋯+d1101+d0 (0≤di≤9, i=0,⋯,k−1, dk−1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 N=100311，则有 2 个 0，3 个 1，和 1 个 3。
输入格式：
每个输入包含 1 个测试用例，即一个不超过 1000 位的正整数 N。
输出格式：
对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。
输入样例：

输出样例：

0:2
1:3
3:1

思路：

以字符串输入，遍历并用计数器记录各个数字出现次数。

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);String string=scanner.nextLine();int[] num= {0,0,0,0,0,0,0,0,0,0};for(int i=0;i<string.length();i++)num[string.charAt(i)-'0']++;for(int i=0;i<10;i++)if(num[i]!=0)System.out.println(i+":"+num[i]);}
}

L1-005 考试座位号 (15 分)

每个 PAT 考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。
输入格式：
输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号试机座位号考试座位号。其中准考证号由 16 位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。
考生信息之后，给出一个正整数 M（≤N），随后一行中给出 M 个待查询的试机座位号码，以空格分隔。
输出格式：
对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。
输入样例：

4
3310120150912233 2 4
3310120150912119 4 1
3310120150912126 1 3
3310120150912002 3 2
2
3 4

输出样例：

3310120150912002 2
3310120150912119 1

思路：

将座位号信息保存在结构体（java为类）中，试机号为下标，直接根据输入的试机号输出，java用BufferedReader，Scanner会运行超时。

代码：

import java.io.*;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader in = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(in.readLine());StuInfo[] stuinfo = new StuInfo[n];for (int i = 0; i < n; i++) {String[] data = in.readLine().split(" ");stuinfo[Integer.parseInt(data[1]) - 1] = new StuInfo(data[0], data[2]);}int m = Integer.parseInt(in.readLine());String[] x = in.readLine().split(" ");for (int i = 0; i < m; i++) {System.out.println(stuinfo[Integer.parseInt(x[i]) - 1].id + " " + stuinfo[Integer.parseInt(x[i]) - 1].x);}}
}class StuInfo {String id;String x;public StuInfo(String id, String x) {super();this.id = id;this.x = x;}
}

L1-015 跟奥巴马一起画方块 (15 分)

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！
输入格式：
输入在一行中给出正方形边长N（3≤N≤21）和组成正方形边的某种字符C，间隔一个空格。
输出格式：
输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的50%（四舍五入取整）。
输入样例：

10 a

输出样例：

aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa

思路：

四舍五入取整即(X+1)/2。

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);int n=scanner.nextInt();String s=scanner.next();for(int i=0;i<(n+1)/2;i++) {for(int j=0;j<n;j++)System.out.print(s);System.out.println();}}
}

L1-016 查验身份证 (15 分)

一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：
首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：
Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。
输入格式：
输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。
输出格式：
按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出
All passed。
输入样例1：

4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X

输出样例1：

12010X198901011234
110108196711301866
37070419881216001X

输入样例2：

2
320124198808240056
110108196711301862

输出样例2：

All passed

思路：

权重与校验码保存在数组中，java用字符串保存校验码方便用indexOf直接取下标。

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);int n=scanner.nextInt(),sum=0,flag=0;int[] weighted={7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};String str="10X98765432";for(int i=0;i<n;i++) {String ID=scanner.next();sum=0;for(int j=0;j<17;j++)sum+=weighted[j]*(ID.charAt(j)-'0');if(ID.charAt(17)!=str.charAt(sum%11)) {System.out.println(ID);flag=1;}}if(flag==0)System.out.println("All passed");}
}

L1-017 到底有多二 (15 分)

一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字
-13142223336是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：3/11×1.5×2×100%，约为81.82%。本题就请你计算一个给定整数到底有多二。
输入格式：
输入第一行给出一个不超过50位的整数N。
输出格式：
在一行中输出N犯二的程度，保留小数点后两位。
输入样例：

-13142223336

输出样例：

81.82%

思路：

“-”不算在数字个数总数中

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);String num=scanner.next();float mul=100;int sum=0,length=0;if(num.charAt(0)=='-') {mul*=1.5;length--;}if((num.charAt(num.length()-1)-'0')%2==0)mul*=2.0;for(int i=0;i<num.length();i++)if(num.charAt(i)=='2')sum++;System.out.printf("%.2f%%",sum*mul/(num.length()+length));}
}

L1-019 谁先倒 (15 分)

划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就输了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。
下面给出甲、乙两人的酒量（最多能喝多少杯不倒）和划拳记录，请你判断两个人谁先倒。
输入格式：
输入第一行先后给出甲、乙两人的酒量（不超过100的非负整数），以空格分隔。下一行给出一个正整数N（≤100），随后N行，每行给出一轮划拳的记录，格式为：
甲喊甲划乙喊乙划
其中喊是喊出的数字，划是划出的数字，均为不超过100的正整数（两只手一起划）。
输出格式：
在第一行中输出先倒下的那个人：A代表甲，B代表乙。第二行中输出没倒的那个人喝了多少杯。题目保证有一个人倒下。注意程序处理到有人倒下就终止，后面的数据不必处理。
输入样例：

输出样例：

A
1

思路：

喊出的数字之和等于任意一个划出的进行操作，其余数据不用管

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);int Al,Bl,al=Al=scanner.nextInt(),bl=Bl=scanner.nextInt(),n=scanner.nextInt();for(int i=0;i<n;i++) {int A=scanner.nextInt(),a=scanner.nextInt(),B=scanner.nextInt(),b=scanner.nextInt();if(a!=b)if(A+B==a)al--;else if (A+B==b)bl--;if(al<0||bl<0)break;}if(al<0)System.out.println("A\n"+(Bl-bl));elseSystem.out.println("B\n"+(Al-al));}
}

L1-025 正整数A+B (15 分)

题的目标很简单，就是求两个正整数A和B的和，其中A和B都在区间[1,1000]。稍微有点麻烦的是，输入并不保证是两个正整数。
输入格式：
输入在一行给出A和B，其间以空格分开。问题是A和B不一定是满足要求的正整数，有时候可能是超出范围的数字、负数、带小数点的实数、甚至是一堆乱码。
注意：我们把输入中出现的第1个空格认为是A和B的分隔。题目保证至少存在一个空格，并且B不是一个空字符串。
输出格式：
如果输入的确是两个正整数，则按格式A + B = 和和输出。如果某个输入不合要求，则在相应位置输出?，显然此时和也是?。
输入样例1：

123 456

输出样例1：

123 + 456 = 579

输入样例2：

22. 18

输出样例2：

? + 18 = ?

输入样例3：

-100 blabla bla...33

输出样例3：

? + ? = ?

思路：

第一个字符有可能是空格，大于1000小于1的都得用“？”代替，java不要用split分割字符串，也不要直接用next,会省略第一个空格，建议用substring

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);String str = scanner.nextLine();int n = str.indexOf(" ");String num1 = str.substring(0, n);String num2 = str.substring(n + 1);if (!IsNum(num1))num1 = "?";if (!IsNum(num2))num2 = "?";System.out.print(num1 + " + " + num2 + " = ");if (!IsNum(num1) || !IsNum(num2))System.out.println("?");elseSystem.out.println(Integer.parseInt(num1) + Integer.parseInt(num2));}private static Boolean IsNum(String s) {boolean flag = true;for (int i = 0; i < s.length(); i++)if (s.charAt(i) < '0' || s.charAt(i) > '9')flag = false;if (s.length() == 0)flag = false;if (flag)if (Integer.parseInt(s) > 1000 || Integer.parseInt(s) < 1)flag = false;return flag;}
}

L1-030 一帮一 (15 分)

“一帮一学习小组”是中小学中常见的学习组织方式，老师把学习成绩靠前的学生跟学习成绩靠后的学生排在一组。本题就请你编写程序帮助老师自动完成这个分配工作，即在得到全班学生的排名后，在当前尚未分组的学生中，将名次最靠前的学生与名次最靠后的异性学生分为一组。
输入格式：
输入第一行给出正偶数N（≤50），即全班学生的人数。此后N行，按照名次从高到低的顺序给出每个学生的性别（0代表女生，1代表男生）和姓名（不超过8个英文字母的非空字符串），其间以1个空格分隔。这里保证本班男女比例是1:1，并且没有并列名次。
输出格式：
每行输出一组两个学生的姓名，其间以1个空格分隔。名次高的学生在前，名次低的学生在后。小组的输出顺序按照前面学生的名次从高到低排列。
输入样例：

8
0 Amy
1 Tom
1 Bill
0 Cindy
0 Maya
1 John
1 Jack
0 Linda

输出样例：

Amy Jack
Tom Linda
Bill Maya
Cindy John

思路：

对半分，前一部分在后一部分绝对有所匹配

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);int n=scanner.nextInt(),m=0,f=0;String[] name=new String[n];int[] sex=new int[n];for (int i=0;i<n;i++) {sex[i]=scanner.nextInt();name[i]=scanner.next();}for(int i=0;i<n/2;i++)for(int j=n-1;j>=n/2;j--)if(sex[i]!=sex[j]&&sex[j]!=-1) {sex[j]=-1;System.out.println(name[i]+" "+name[j]);break;}}
}

L1-033 出生年 (15 分)

以上是新浪微博中一奇葩贴：“我出生于1988年，直到25岁才遇到4个数字都不相同的年份。”也就是说，直到2013年才达到“4个数字都不相同”的要求。本题请你根据要求，自动填充“我出生于y年，直到x岁才遇到n个数字都不相同的年份”这句话。
输入格式：
输入在一行中给出出生年份y和目标年份中不同数字的个数n，其中y在[1, 3000]之间，n可以是2、或3、或4。注意不足4位的年份要在前面补零，例如公元1年被认为是0001年，有2个不同的数字0和1。
输出格式：
根据输入，输出x和能达到要求的年份。数字间以1个空格分隔，行首尾不得有多余空格。年份要按4位输出。注意：所谓n个数字都不相同”是指不同的数字正好是n个。如“2013”被视为满足“4位数字都不同”的条件，但不被视为满足2位或3位数字不同的条件。
输入样例1：

1988 4

输出样例1：

25 2013

输入样例2：

1 2

输出样例2：

0 0001

思路：

整除取余判断

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);int year=scanner.nextInt(),x=scanner.nextInt(),count=0,y=0;while(true) {int[] flag=new int[10];flag[year%10]++;flag[year/10%10]++;flag[year/100%10]++;flag[year/1000%10]++;for(int i=0;i<10;i++)if(flag[i]!=0)y++;if(y==x)break;y=0;year++;count++;}System.out.printf("%d %04d",count,year);}
}

L1-035 情人节 (15 分)

以上是朋友圈中一奇葩贴：“2月14情人节了，我决定造福大家。第2个赞和第14个赞的，我介绍你俩认识…………咱三吃饭…你俩请…”。现给出此贴下点赞的朋友名单，请你找出那两位要请客的倒霉蛋。
输入格式：
输入按照点赞的先后顺序给出不知道多少个点赞的人名，每个人名占一行，为不超过10个英文字母的非空单词，以回车结束。一个英文句点.标志输入的结束，这个符号不算在点赞名单里。
输出格式：
根据点赞情况在一行中输出结论：若存在第2个人A和第14个人B，则输出“A and B are inviting you to dinner…”；若只有A没有B，则输出“A is the only one for you…”；若连A都没有，则输出“Momo… No one is for you …”。
输入样例1：

GaoXZh
Magi
Einst
Quark
LaoLao
FatMouse
ZhaShen
fantacy
latesum
SenSen
QuanQuan
whatever
whenever
Potaty
hahaha
.

输出样例1：

Magi and Potaty are inviting you to dinner...

输入样例2：

LaoLao
FatMouse
whoever
.

输出样例2：

FatMouse is the only one for you...

输入样例3：

LaoLao
.

输出样例3：

Momo... No one is for you ...

思路：

保存2和14位，其余舍弃

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);String peo1 = null,peo2=null;int count=0;while(true) {count++;String str=scanner.next();if(count==2)peo1=str;else if(count==14)peo2=str;if(str.equals("."))break;}if(count-1>=14)System.out.println(peo1+" and "+peo2+" are inviting you to dinner...");else if(count-1>=2)System.out.println(peo1+" is the only one for you...");elseSystem.out.println("Momo... No one is for you ...");}
}

L1-044 稳赢 (15 分)

大家应该都会玩“锤子剪刀布”的游戏：两人同时给出手势，胜负规则如图所示：

现要求你编写一个稳赢不输的程序，根据对方的出招，给出对应的赢招。但是！为了不让对方输得太惨，你需要每隔K次就让一个平局。
输入格式：
输入首先在第一行给出正整数K（≤10），即平局间隔的次数。随后每行给出对方的一次出招：ChuiZi代表“锤子”、 JianDao代表“剪刀”、 Bu代表“布”。 End代表输入结束，这一行不要作为出招处理。
输出格式：
对每一个输入的出招，按要求输出稳赢或平局的招式。每招占一行。
输入样例：

2
ChuiZi
JianDao
Bu
JianDao
Bu
ChuiZi
ChuiZi
End

输出样例：

Bu
ChuiZi
Bu
ChuiZi
JianDao
ChuiZi
Bu

思路：

将克制关系存在数组中，找到输入的在第几位，加一模三输出，java用BufferedReader ，Scanner会运行超时

代码：

import java.io.*;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader in = new BufferedReader(new InputStreamReader(System.in));int n = Integer.parseInt(in.readLine()), flag = 0;String[] str = {"JianDao", "ChuiZi", "Bu"};while (true) {String s = in.readLine();if (s.equals("End"))break;if (flag == n) {System.out.println(s);flag = -1;} elseSystem.out.println(str[IndexOf(str, s) % 3]);flag++;}}private static int IndexOf(String[] str, String next) {for (int i = 0; i < 3; i++)if (next.equals(str[i]))return i + 1;return 0;}
}

L1-048 矩阵A乘以B (15 分)

给定两个矩阵A和B，要求你计算它们的乘积矩阵AB。需要注意的是，只有规模匹配的矩阵才可以相乘。即若A有Ra 行、Ca 列，B有Rb 行、Cb 列，则只有Ca 与Rb 相等时，两个矩阵才能相乘。
输入格式：
输入先后给出两个矩阵A和B。对于每个矩阵，首先在一行中给出其行数R和列数C，随后R行，每行给出C个整数，以1个空格分隔，且行首尾没有多余的空格。输入保证两个矩阵的R和C都是正数，并且所有整数的绝对值不超过100。
输出格式：
若输入的两个矩阵的规模是匹配的，则按照输入的格式输出乘积矩阵AB，否则输出Error: Ca != Rb，其中Ca是A的列数，Rb是B的行数。
输入样例1：

2 3
1 2 3
4 5 6
3 4
7 8 9 0
-1 -2 -3 -4
5 6 7 8

输出样例1：

2 4
20 22 24 16
53 58 63 28

输入样例2：

输出样例2：

Error: 2 != 3

思路：

第一个矩阵的行和第二个矩阵的列相等，用三个循环嵌套，第一个循环控制第一个矩阵的行数，第二个循环控制第二个矩阵的列数，第三个循环控制相乘的两个元素，java用BufferedReader
，Scanner会运行超时。

代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main{static BufferedReader in = new BufferedReader(new InputStreamReader(System.in));public static void main(String[] args) throws IOException {String[] x = in.readLine().split(" ");int[][] arr1 = Initialize(Integer.parseInt(x[0]), Integer.parseInt(x[1]));x = in.readLine().split(" ");int[][] arr2 = Initialize(Integer.parseInt(x[0]), Integer.parseInt(x[1]));in.close();if (arr1[0].length != arr2.length)System.out.println("Error: " + arr1[0].length + " != " + arr2.length);else {System.out.println(arr1.length + " " + arr2[0].length);for (int i = 0; i < arr1.length; i++) {for (int j = 0; j < arr2[0].length; j++) {int sum = 0;for (int k = 0; k < arr2.length; k++) {sum += arr1[i][k] * arr2[k][j];}System.out.print(sum);if (j < arr2[0].length - 1)System.out.print(" ");}System.out.println();}}}static int[][] Initialize(int m, int n) throws IOException {int[][] arr = new int[m][n];for (int i = 0; i < m; i++) {String[] x = in.readLine().split(" ");for (int j = 0; j < n; j++) {arr[i][j] = Integer.parseInt(x[j]);}}return arr;}
}

L1-050 倒数第N个字符串 (15 分)

给定一个完全由小写英文字母组成的字符串等差递增序列，该序列中的每个字符串的长度固定为 L，从 L 个 a 开始，以 1 为步长递增。例如当 L 为 3 时，序列为 { aaa, aab, aac, …, aaz, aba, abb, …, abz, …, zzz }。这个序列的倒数第27个字符串就是 zyz。对于任意给定的 L，本题要求你给出对应序列倒数第 N 个字符串。
输入格式：
输入在一行中给出两个正整数 L（2 ≤ L ≤ 6）和 N（≤105 ）。
输出格式：
在一行中输出对应序列倒数第 N 个字符串。题目保证这个字符串是存在的。
输入样例：

3 7417

输出样例：

pat

思路：

看做26进制数计算

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereString str="abcdefghijklmnopqrstuvwxyz",print="";Scanner scanner = new Scanner(System.in);int x=scanner.nextInt(),y=scanner.nextInt();int num=(int) Math.pow(26, x)-y;for(int i=0;i<x;i++) {print+=str.charAt(num%26);num=num/26;}for(int i=x-1;i>=0;i--)System.out.print(print.charAt(i));}
}

L1-054 福到了 (15 分)

“福”字倒着贴，寓意“福到”。不论到底算不算民俗，本题且请你编写程序，把各种汉字倒过来输出。这里要处理的每个汉字是由一个 N × N 的网格组成的，网格中的元素或者为字符 @ 或者为空格。而倒过来的汉字所用的字符由裁判指定。
输入格式：
输入在第一行中给出倒过来的汉字所用的字符、以及网格的规模 N （不超过100的正整数），其间以 1 个空格分隔；随后 N 行，每行给出 N 个字符，或者为 @ 或者为空格。
输出格式：
输出倒置的网格，如样例所示。但是，如果这个字正过来倒过去是一样的，就先输出bu yong dao le，然后再用输入指定的字符将其输出。
输入样例 1：

$ 9@  @@@@@
@@@  @@@ @   @ @
@@@  @@@
@@@ @@@@@
@@@ @ @ @
@@@ @@@@@@  @ @ @@  @@@@@

输出样例 1：

$$$$$  $
$ $ $  $
$$$$$ $$$
$ $ $ $$$
$$$$$ $$$$$$  $$$$ $   $ $$$  $$$
$$$$$  $

输入样例 2：

& 3
@@@@
@@@

输出样例 2：

bu yong dao le
&&&&
&&&

思路：

倒序之后和原字符串对比，在输出

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);String ch = scanner.next();int n = scanner.nextInt();scanner.nextLine();String[] arr1 = new String[n], arr2 = new String[n];for (int i = 0; i < n; i++) {arr1[i] = Replace(scanner.nextLine(), ch);arr2[n - i - 1] = Pour(arr1[i]);}boolean flag = true;for (int i = 0; i < n; i++)if (!arr1[i].equals(arr2[i]))flag = false;if (flag)System.out.println("bu yong dao le");for (int i = 0; i < n; i++)System.out.println(arr2[i]);}private static String Replace(String string, String ch) {String s = "";for (int i = 0; i < string.length(); i++)if (string.charAt(i) != ' ')s = s + ch;elses = s + string.charAt(i);return s;}private static String Pour(String string) {String s = "";for (int i = string.length() - 1; i >= 0; i--)s = s + string.charAt(i);return s;}
}

L1-058 6翻了 (15 分)

“666”是一种网络用语，大概是表示某人很厉害、我们很佩服的意思。最近又衍生出另一个数字“9”，意思是“6翻了”，实在太厉害的意思。如果你以为这就是厉害的最高境界，那就错啦 —— 目前的最高境界是数字“27”，因为这是 3 个 “9”！
本题就请你编写程序，将那些过时的、只会用一连串“6666……6”表达仰慕的句子，翻译成最新的高级表达。
输入格式：
输入在一行中给出一句话，即一个非空字符串，由不超过 1000 个英文字母、数字和空格组成，以回车结束。
输出格式：
从左到右扫描输入的句子：如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。
输入样例：

it is so 666 really 6666 what else can I say 6666666666

输出样例：

it is so 666 really 9 what else can I say 27

思路：

串的模式匹配，java用replaceAll和正则表达式直接替换

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereSystem.out.println(new Scanner(System.in).nextLine().replaceAll("6{10,}", "27").replaceAll("6{4,}", "9"));}
}

L1-062 幸运彩票 (15 分)

彩票的号码有 6 位数字，若一张彩票的前 3 位上的数之和等于后 3 位上的数之和，则称这张彩票是幸运的。本题就请你判断给定的彩票是不是幸运的。
输入格式：
输入在第一行中给出一个正整数 N（≤ 100）。随后 N 行，每行给出一张彩票的 6 位数字。
输出格式：
对每张彩票，如果它是幸运的，就在一行中输出 You are lucky!；
否则输出 Wish you good luck.。
输入样例：

2
233008
123456

输出样例：

You are lucky!
Wish you good luck.

思路：

可用字符串也可用C的%1d输入

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner=new Scanner(System.in);int n=scanner.nextInt();scanner.nextLine();for(int i=0;i<n;i++) {char[] s=scanner.nextLine().toCharArray();if(s[0]+s[1]+s[2]==s[3]+s[4]+s[5])System.out.println("You are lucky!");elseSystem.out.println("Wish you good luck.");}}
}

L1-069 胎压监测 (15 分)

小轿车中有一个系统随时监测四个车轮的胎压，如果四轮胎压不是很平衡，则可能对行车造成严重的影响。

让我们把四个车轮 —— 左前轮、右前轮、右后轮、左后轮 —— 顺次编号为 1、2、3、4。本题就请你编写一个监测程序，随时监测四轮的胎压，并给出正确的报警信息。报警规则如下：

如果所有轮胎的压力值与它们中的最大值误差在一个给定阈值内，并且都不低于系统设定的最低报警胎压，则说明情况正常，不报警；
如果存在一个轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统设定的最低报警胎压，则不仅要报警，而且要给出可能漏气的轮胎的准确位置；
如果存在两个或两个以上轮胎的压力值与它们中的最大值误差超过了阈值，或者低于系统

设定的最低报警胎压，则报警要求检查所有轮胎。
输入格式：
输入在一行中给出 6 个 [0, 400] 范围内的整数，依次为 1~4 号轮胎的胎压、最低报警胎压、以及胎压差的阈值。
输出格式：
根据输入的胎压值给出对应信息：
如果不用报警，输出 Normal；
如果有一个轮胎需要报警，输出 Warning: please check #X!，其中 X 是出问题的轮胎的编号；
如果需要检查所有轮胎，输出 Warning: please check all the tires!。
输入样例1：

242 251 231 248 230 20

输出样例1：

Normal

输入样例2：

242 251 232 248 230 10

输出样例2：

Warning: please check #3!

输入样例3：

240 251 232 248 240 10

输出样例3：

Warning: please check all the tires!

思路：

判断条件不包含等于

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scan = new Scanner(System.in);int[] T = {scan.nextInt(), scan.nextInt(), scan.nextInt(), scan.nextInt()};int index = 0, flag = 0, low = scan.nextInt(), poor = scan.nextInt();for (int i = 0; i < 4; i++)if (Max(T) - T[i] > poor || T[i] < low) {index = i + 1;flag++;}if (flag == 0)System.out.println("Normal");else if (flag == 1)System.out.println("Warning: please check #" + index + "!");elseSystem.out.println("Warning: please check all the tires!");}private static int Max(int[] t) {int max = 0;for (int i = 0; i < t.length; i++)if (t[i] > max)max = t[i];return max;}
}

L1-070 吃火锅 (15 分)

以上图片来自微信朋友圈：这种天气你有什么破事打电话给我基本没用。但是如果你说“吃火锅”，那就厉害了，我们的故事就开始了。
本题要求你实现一个程序，自动检查你朋友给你发来的信息里有没有 chi1 huo3 guo1。
输入格式：
输输入每行给出一句不超过 80 个字符的、以回车结尾的朋友信息，信息为非空字符串，仅包括字母、数字、空格、可见的半角标点符号。当读到某一行只有一个英文句点 . 时，输入结束，此行不算在朋友信息里。
输出格式：
首先在一行中输出朋友信息的总条数。然后对朋友的每一行信息，检查其中是否包含 chi1 huo3 guo1，并且统计这样厉害的信息有多少条。在第二行中首先输出第一次出现 chi1 huo3 guo1 的信息是第几条（从 1 开始计数），然后输出这类信息的总条数，其间以一个空格分隔。题目保证输出的所有数字不超过 100。
如果朋友从头到尾都没提 chi1 huo3 guo1 这个关键词，则在第二行输出一个表情 -_-#。
输入样例1：

Hello!
are you there?
wantta chi1 huo3 guo1?
that's so li hai le
our story begins from chi1 huo3 guo1 le
.

输出样例1：

5
3 2

输入样例2：

Hello!
are you there?
wantta qi huo3 guo1 chi1huo3guo1?
that's so li hai le
our story begins from ci1 huo4 guo2 le
.

输出样例2：

5
-_-#

思路：

串的模式匹配，java用contains直接判断是否包含此子串

代码：

import java.io.*;public class Main{public static void main(String[] args) throws IOException {// write your code hereBufferedReader scan = new BufferedReader(new InputStreamReader(System.in));int index = 0, count = 0, sum = 0;while (true) {String str = scan.readLine();if (str.equals("."))break;else {count++;if (str.contains("chi1 huo3 guo1")) {if (index == 0)index = count;sum++;}}}System.out.println(count);if (index != 0)System.out.printf("%d %d", index, sum);elseSystem.out.println("-_-#");}
}

L1-077 大笨钟的心情 (15 分)

有网友问：未来还会有更多大笨钟题吗？笨钟回复说：看心情……
本题就请你替大笨钟写一个程序，根据心情自动输出回答。
输入格式：
输入在一行中给出 24 个 [0, 100] 区间内的整数，依次代表大笨钟在一天 24 小时中，每个小时的心情指数。

随后若干行，每行给出一个 [0, 23] 之间的整数，代表网友询问笨钟这个问题的时间点。当出现非法的时间点时，表示输入结束，这个非法输入不要处理。题目保证至少有 1 次询问。
输出格式：
对每一次提问，如果当时笨钟的心情指数大于 50，就在一行中输出心情指数 Yes，否则输出心情指数 No。
输入样例：

80 75 60 50 20 20 20 20 55 62 66 51 42 33 47 58 67 52 41 20 35 49 50 63
17
7
3
15
-1

输出样例：

52 Yes
20 No
50 No
58 Yes

思路：

数组保存，直接判断输出

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);int[] number = new int[24];for (int i = 0; i < 24; i++)number[i]=scanner.nextInt();while (true){int x=scanner.nextInt();if (x == -1)break;System.out.print(number[x]+" ");if (number[x]>50)System.out.println("Yes");elseSystem.out.println("No");}}
}

L1-078 吉老师的回归 (15 分)

曾经在天梯赛大杀四方的吉老师决定回归天梯赛赛场啦！

为了简化题目，我们不妨假设天梯赛的每道题目可以用一个不超过 500 的、只包括可打印符号的字符串描述出来，如：Problem A: Print “Hello world!”。

众所周知，吉老师的竞赛水平非常高超，你可以认为他每道题目都会做（事实上也是……）。因此，吉老师会按照顺序看题并做题。但吉老师水平太高了，所以签到题他就懒得做了（浪费时间），具体来说，假如题目的字符串里有 qiandao 或者 easy（区分大小写）的话，吉老师看完题目就会跳过这道题目不做。

现在给定这次天梯赛总共有几道题目以及吉老师已经做完了几道题目，请你告诉大家吉老师现在正在做哪个题，或者吉老师已经把所有他打算做的题目做完了。

提醒：天梯赛有分数升级的规则，如果不做签到题可能导致团队总分不足以升级，一般的选手请千万不要学习吉老师的酷炫行为！。
输入格式：
输入第一行是两个正整数 N,M (1≤M≤N≤30)，表示本次天梯赛有 N 道题目，吉老师现在做完了 M 道。

接下来 N 行，每行是一个符合题目描述的字符串，表示天梯赛的题目内容。吉老师会按照给出的顺序看题——第一行就是吉老师看的第一道题，第二行就是第二道，以此类推。
输出格式：
在一行中输出吉老师当前正在做的题目对应的题面（即做完了 M 道题目后，吉老师正在做哪个题）。如果吉老师已经把所有他打算做的题目做完了，输出一行 Wo AK le。
输入样例1：

5 1
L1-1 is a qiandao problem.
L1-2 is so...easy.
L1-3 is Easy.
L1-4 is qianDao.
Wow, such L1-5, so easy.

输出样例1：

L1-4 is qianDao.

输入样例2：

5 4
L1-1 is a-qiandao problem.
L1-2 is so easy.
L1-3 is Easy.
L1-4 is qianDao.
Wow, such L1-5, so!!easy.

输出样例2：

Wo AK le

思路：

串的模式匹配，java用contains判断是否包含关键字符串

代码：

import java.util.Scanner;public class Main{public static void main(String[] args) {// write your code hereScanner scanner = new Scanner(System.in);int n = scanner.nextInt(), m = scanner.nextInt(),count=0;scanner.nextLine();for (int i = 0; i < n; i++) {String s = scanner.nextLine();if (!s.contains("qiandao")&&!s.contains("easy")) {count++;}if (count>m){System.out.println(s);return;}}System.out.println("Wo AK le");}
}