团体程序天梯赛
- L1-001 Hello World
- L1-002 打印沙漏
- L1-003 个位数统计
- L1-004 计算摄氏温度
- L1-005 考试座位号
- L1-006 连续因子
- L1-007 念数字
- L1-008 求整数段和
- L1-009 N个数求和
- L1-010 比较大小
- L1-011 A-B
- L1-012 计算指数
- L1-013 计算阶乘和
- L1-014 简单题
- L1-015 跟奥巴马一起画方块
- L1-016 查验身份证
- L1-017 到底有多二
- L1-018 大笨钟
- L1-019 谁先倒
- L1-020 帅到没朋友
- L1-021 重要的话说三遍
- L1-022 奇偶分家
- L1-023 输出GPLT
- L1-024 后天
- L1-025 正整数A+B
- L1-026 I Love GPLT
- L1-027 出租
- L1-028 判断素数
- L1-032 Left-pad
- L1-034 点赞
L1-001 Hello World
单位 浙江大学
这道超级简单的题目没有任何输入。
你只需要在一行中输出著名短句“Hello World!”就可以了。
输入样例：
无
输出样例：
Hello World!
代码长度限制 16 KB 时间限制 400 ms内存限制 64 MB
public class Main{
public static void main(String[] args){
System.out.println("Hello World!");
}
}
L1-002 打印沙漏
本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印
*****
***
*
***
*****
所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。
给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。
输入格式:
输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。
输出格式:
首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。
输入样例:
19 *
输出样例:
*****
***
*
***
*****
2
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
int n,i=1,j,k,l,num,sum,stay;
String c;
Scanner sc =new Scanner(System.in);
num=sc.nextInt();
c=sc.next();
sum=1;
while(sum<=(num-2*(i+2))) {
i=i+2;
sum+=i*2;
}
n=i;
stay=num-sum;
for(k=0;k<((i+1)/2);k++) {
for(l=0;l<k;l++)
System.out.print(" ");
for(j=n;0<j;j--) {
System.out.print(c);
}
n=n-2;
System.out.print("\n");
}
n=3;
for(k=((i-1)/2);0<k;k--) {
for(l=0;l<k-1;l++)
System.out.print(" ");
for(j=0;j<n;j++) {
System.out.print(c);
}
n=n+2;
System.out.print("\n");
}
System.out.println(stay);
}
}
L1-003 个位数统计
给定一个 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 的升序输出。
输入样例：
100311
输出样例：
0:2
1:3
3:1
代码长度限制16 KB时间限制400 ms内存限制64 MB
import java.util.Scanner;
public class Main{
public static void main(String []args){
Scanner sc=new Scanner(System.in);
int []a=new int[10];
String str=sc.next();
for(int i=0;i<str.length();++i){
a[str.charAt(i)-'0']++;
}
for(int i=0;i<a.length;++i){
if(a[i]!=0){
System.out.println(i+":"+a[i]);
}
}
}
}
L1-004 计算摄氏温度
给定一个华氏温度F，本题要求编写程序，计算对应的摄氏温度C。计算公式：C=5×(F−32)/9。题目保证输入与输出均在整型范围内。
输入格式:
输入在一行中给出一个华氏温度。
输出格式:
在一行中按照格式“Celsius = C”输出对应的摄氏温度C的整数值。
输入样例:
150
输出样例:
Celsius = 65
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int F = Integer.parseInt(br.readLine());
System.out.println("Celsius = "+(5*(F-32)/9));
}
}
L1-005 考试座位号
每个 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
代码长度限制 16 KB 时间限制 200 ms 内存限制 64 MB
下面为超时代码，后续再更新
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
String[] stu = new String[n];
for(int i=0;i<n;i++){
String[] str=br.readLine().split(" ");
int testSit = Integer.parseInt(str[1]);
stu[testSit-1] = str[0]+" "+str[2];
}
int n1 = Integer.parseInt(br.readLine());
String[] str = br.readLine().split(" ");
for(int i = 0;i<n1;i++){
int testSit = Integer.parseInt(str[i]);
System.out.println(stu[testSit-1]);
}
br.close();
}
}
L1-006 连续因子
一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3 个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。
输入格式：
输入在一行中给出一个正整数 N（1<N<231）。
输出格式：
首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1因子2……*因子k 的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。
输入样例：
630
输出样例：
3
5*6*7
鸣谢用户 漏穿雪 补充数据！
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
测试点1，是测试因子序列乘积是否大于整数
测试点3，是测试因子序列乘积是否为因子
测试点4，是测试平方数，如4，9，16等，其只有一个因子便是其根号值
测试点5，6是测试素数，如2，3等，因1不为因子，所以其本身便是1个因子
其余测试点应该是测试基本逻辑。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br =new BufferedReader(new InputStreamReader(System.in));
int num = Integer.parseInt(br.readLine());
int left = 2;
int right = num/2;
int max=0;
StringBuilder res = new StringBuilder("");
if(judgePrime(num)) {
System.out.println("1\n"+num);
return;
}
while(left<=right){
if(left*right==num){
StringBuilder itemres = new StringBuilder("");
itemres.append(left+"*");
int val=left;
for(int i=left;i<=right;i++){
int item = i+1;
int itemmax=1;
val*=item;
while(num%item==0&&num%val==0){
itemmax++;
itemres.append((item++)+"*");
val*=item;
}
if(itemmax>max){
max=itemmax;
res = itemres;
}
break;
}
}
left++;
right=num/left;
}
res.deleteCharAt(res.length()-1);
System.out.println(max+"\n"+res.toString());
br.close();
}
public static boolean judgePrime(int number){
if(number<2)
return false;
else if(number<4)
return true;
int len = (int) Math.sqrt(number);
for(int i=2;i<=len;i++){
if(number%i==0)
return false;
}
return true;
}
}
L1-007 念数字
输入一个整数，输出每个数字对应的拼音。当整数为负数时，先输出fu字。十个数字对应的拼音如下：
0: ling
1: yi
2: er
3: san
4: si
5: wu
6: liu
7: qi
8: ba
9: jiu
输入格式：
输入在一行中给出一个整数，如：1234。
提示：整数包括负数、零和正数。
输出格式：
在一行中输出这个整数对应的拼音，每个数字的拼音之间用空格分开，行末没有最后的空格。如
yi er san si。
输入样例：
-600
输出样例：
fu liu ling ling
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
String[] num= {"ling","yi","er","san","si","wu","liu","qi","ba","jiu"};
String cc;
int i;
cc=sc.next();
for(i=0;i<cc.length()-1;i++) {
if(cc.charAt(i)=='-')
System.out.print("fu ");
else
System.out.print(num[cc.charAt(i)-'0']+" ");
}
System.out.print(num[cc.charAt(i)-'0']);
}
}
L1-008 求整数段和
给定两个整数A和B，输出从A到B的所有整数以及这些数的和。
输入格式：
输入在一行中给出2个整数A和B，其中−100≤A≤B≤100，其间以空格分隔。
输出格式：
首先顺序输出从A到B的所有整数，每5个数字占一行，每个数字占5个字符宽度，向右对齐。最后在一行中按Sum = X的格式输出全部数字的和X。
输入样例：
-3 8
输出样例：
-3 -2 -1 0 1
2 3 4 5 6
7 8
Sum = 30
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int min = sc.nextInt();
int max = sc.nextInt();
for(int i = min ;i<=max;i++){
System.out.printf("%5d",i);
if((i-min+1)%5==0&&(i-min)!=0)
System.out.println();
}
if(max-min==4)
System.out.println("Sum = "+(max+min)*(max-min+1)/2);
else
System.out.println("\nSum = "+(max+min)*(max-min+1)/2);
}
}
L1-009 N个数求和
本题的要求很简单，就是求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：
2
输入样例3：
3
1/3 -1/6 1/8
输出样例3：
7/24
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
String[] str = br.readLine().split(" ");
int up = Integer.parseInt(str[0].split("/")[0]);
int down = Integer.parseInt(str[0].split("/")[1]);
for(int i = 1;i<n;i++){
int itemup = Integer.parseInt(str[i].split("/")[0]);
int itemdown = Integer.parseInt(str[i].split("/")[1]);
up=up*itemdown+itemup*down;
down *= itemdown;
int give = gcd(up,down);
up/=give;
down/=give;
}
if(down==1)
System.out.println(up);
else{
if(up>=down)
System.out.println((up/down)+" "+(up%down)+"/"+down);
else
System.out.println(up+"/"+down);
}
}
static int gcd(int a,int b){
if(b==0)
return a;
int r=a%b;
return gcd(b,r);
}
}
该题需要考虑每次加完之后约分，防止出现超出整数值的范围
L1-010 比较大小
本题要求将输入的任意3个整数从小到大输出。
输入格式:
输入在一行中给出3个整数，其间以空格分隔。
输出格式:
在一行中将3个整数从小到大输出，其间以“->”相连。
输入样例:
4 2 8
输出样例:
2->4->8
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int max = (a>b?a:b)>c?(a>b?a:b):c;
int min = (a<b?a:b)<c?(a<b?a:b):c;
int mid = a+b+c-min-max;
System.out.println(min+"->"+mid+"->"+max);
}
}
L1-011 A-B
本题要求你计算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!
代码长度限制 16 KB 时间限制 150 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
String replace = br.readLine();
StringBuilder str1 = new StringBuilder();
int[] asc = new int[128];
char[] chars1 = str.toCharArray();
char[] chars = replace.toCharArray();
for (int i = 0; i < chars.length; i++) {
asc[chars[i]] = 1;
}
for (int i = 0; i < chars1.length; i++) {
if (asc[chars1[i]] != 1){
str1.append(chars1[i]);
}
}
System.out.println(str1.toString());
}
}
直接使用replace函数容易超时，故考虑使用字符来判断。
L1-012 计算指数
真的没骗你，这道才是简单题 —— 对任意给定的不超过 10 的正整数 n，要求你输出 2n。不难吧？
输入格式：
输入在一行中给出一个不超过 10 的正整数 n。
输出格式：
在一行中按照格式 2^n = 计算结果 输出 2n 的值。
输入样例：
5
输出样例：
2^5 = 32
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
System.out.println("2^"+n+" = "+(int)Math.pow(2,n));
}
}
L1-013 计算阶乘和
对于给定的正整数N，需要你计算 S=1!+2!+3!+…+N!。
输入格式：
输入在一行中给出一个不超过10的正整数N。
输出格式：
在一行中输出S的值。
输入样例：
3
输出样例：
9
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int num = Integer.parseInt(br.readLine());
int res=0;
for(int i=1;i<=num;i++)
res+=factorial(i);
System.out.println(res);
}
static int factorial(int num){
int res = 1;
for(int i = 1;i<=num;i++)
res*=i;
return res;
}
}
L1-014 简单题
这次真的没骗你 —— 这道超级简单的题目没有任何输入。
你只需要在一行中输出事实：This is a simple problem. 就可以了。
输入样例：
无
输出样例：
This is a simple problem.
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
public class Main {
public static void main(String[] args){
System.out.println("This is a simple problem.");
}
}
L1-015 跟奥巴马一起画方块
美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！
输入格式：
输入在一行中给出正方形边长N（3≤N≤21）和组成正方形边的某种字符C，间隔一个空格。
输出格式：
输出由给定字符C画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的50%（四舍五入取整）。
输入样例：
10 a
输出样例：
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
aaaaaaaaaa
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] str = br.readLine().split(" ");
int num = Integer.parseInt(str[0]);
for(int i=0;i<(int)(num/2.0+0.5);i++){
for(int j=0;j<num;j++)
System.out.print(str[1]);
System.out.println();
}
}
}
L1-016 查验身份证
一个合法的身份证号码由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
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
String id;
int n,i,m,j,sum=0,cd,flag=0;
char[] M= {'1','0','X','9','8','7','6','5','4','3','2'};
int[] num= {7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2};
Scanner sc =new Scanner(System.in);
n=sc.nextInt();
cd=n;
for(i=0;i<n;i++) {
id=sc.next();
for(j=0;j<17;j++) {
if(id.charAt(j)>'9'||id.charAt(j)<'0')
{
System.out.println(id);
flag=1;
break;
}
sum+=(id.charAt(j)-'0')*num[j];
}
m=sum%11;
if(flag!=1) {
if(id.charAt(17)!=M[m])
System.out.println(id);
else
cd--;
}
flag=0;
sum=0;
}
if(cd==0&&n!=0)
System.out.println("All passed");
sc.close();
}
}
L1-017 到底有多二
一个整数“犯二的程度”定义为该数字中包含2的个数与其位数的比值。如果这个数是负数，则程度增加0.5倍；如果还是个偶数，则再增加1倍。例如数字-13142223336是个11位数，其中有3个2，并且是负数，也是偶数，则它的犯二程度计算为：3/11×1.5×2×100%，约为81.82%。本题就请你计算一个给定整数到底有多二。
输入格式：
输入第一行给出一个不超过50位的整数N。
输出格式：
在一行中输出N犯二的程度，保留小数点后两位。
输入样例：
-13142223336
输出样例：
81.82%
鸣谢安阳师范学院段晓云老师和软件工程五班李富龙同学补充测试数据！
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
String cc;
int sum=0,aa=1,l;
double flag=1,ll;
Scanner sc =new Scanner(System.in);
cc=sc.next();
l=cc.length();
for(int i=0;i<cc.length();i++) {
if(cc.charAt(0)=='-')
{flag=1.5;
l=cc.length()-1;
}
if(cc.charAt(i)=='2')
sum++;
}
if((cc.charAt(cc.length()-1))%2==0)
aa=2;
ll=1.0*sum/l*aa*flag*100;
String bb=String.format("%.2f", ll);
System.out.println(bb+"%");
sc.close();
}
}
L1-018 大笨钟
微博上有个自称“大笨钟V”的家伙，每天敲钟催促码农们爱惜身体早点睡觉。不过由于笨钟自己作息也不是很规律，所以敲钟并不定时。一般敲钟的点数是根据敲钟时间而定的，如果正好在某个整点敲，那么“当”数就等于那个整点数；如果过了整点，就敲下一个整点数。另外，虽然一天有24小时，钟却是只在后半天敲1~12下。例如在23:00敲钟，就是“当当当当当当当当当当当”，而到了23:01就会是“当当当当当当当当当当当当”。在午夜00:00到中午12:00期间（端点时间包括在内），笨钟是不敲的。
下面就请你写个程序，根据当前时间替大笨钟敲钟。
输入格式：
输入第一行按照hh:mm的格式给出当前时间。其中hh是小时，在00到23之间；mm是分钟，在00到59之间。
输出格式：
根据当前时间替大笨钟敲钟，即在一行中输出相应数量个Dang。如果不是敲钟期，则输出：
Only hh:mm. Too early to Dang.
其中hh:mm是输入的时间。
输入样例1：
19:05
输出样例1：
DangDangDangDangDangDangDangDang
输入样例2：
07:05
输出样例2：
Only 07:05. Too early to Dang.
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String time = br.readLine();
int h,m;
h= Integer.parseInt(time.split(":")[0]);
m= Integer.parseInt(time.split(":")[1]);
if(h<=12)
System.out.printf("Only %02d:%02d. Too early to Dang.",h,m);
else{
if(m!=0)
h=h-11;
else
h=h-12;
for(int i=0;i<h;i++)
System.out.printf("Dang");
}
br.close();
}
}
L1-019 谁先倒
划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就输了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。
下面给出甲、乙两人的酒量（最多能喝多少杯不倒）和划拳记录，请你判断两个人谁先倒。
输入格式：
输入第一行先后给出甲、乙两人的酒量（不超过100的非负整数），以空格分隔。下一行给出一个正整数N（≤100），随后N行，每行给出一轮划拳的记录，格式为：
甲喊 甲划 乙喊 乙划
其中喊是喊出的数字，划是划出的数字，均为不超过100的正整数（两只手一起划）。
输出格式：
在第一行中输出先倒下的那个人：A代表甲，B代表乙。第二行中输出没倒的那个人喝了多少杯。题目保证有一个人倒下。注意程序处理到有人倒下就终止，后面的数据不必处理。
输入样例：
1 1
6
8 10 9 12
5 10 5 10
3 8 5 12
12 18 1 13
4 16 12 15
15 1 1 16
输出样例：
A
1
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] str = br.readLine().split(" ");
int A=Integer.parseInt(str[0]),B=Integer.parseInt(str[1]);
int aDrink=0,bDrink=0;
int n = Integer.parseInt(br.readLine());
for(int i=0;i<n;i++){
String[] item = br.readLine().split(" ");
int aSay = Integer.parseInt(item[0]),aDo=Integer.parseInt(item[1]);
int bSay = Integer.parseInt(item[2]),bDo=Integer.parseInt(item[3]);
if(aDo==(aSay+bSay)&&bDo!=(aSay+bSay))
aDrink++;
if(bDo==(aSay+bSay)&&aDo!=(aSay+bSay))
bDrink++;
if(aDrink>A){
System.out.println("A\n"+bDrink);
break;
}
if(bDrink>B){
System.out.println("B\n"+aDrink);
break;
}
}
br.close();
}
}
L1-020 帅到没朋友
当芸芸众生忙着在朋友圈中发照片的时候，总有一些人因为太帅而没有朋友。本题就要求你找出那些帅到没有朋友的人。
输入格式：
输入第一行给出一个正整数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
代码长度限制 16 KB 时间限制 200 ms 内存限制 64 MB
最后一测试点超时，未完善，后续再完善
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
static boolean[] flag = new boolean[100001];
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
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-021 重要的话说三遍
这道超级简单的题目没有任何输入。
你只需要把这句很重要的话 —— “I’m gonna WIN!”——连续输出三遍就可以了。
注意每遍占一行，除了每行的回车不能有任何多余字符。
输入样例：
无
输出样例：
I'm gonna WIN!
I'm gonna WIN!
I'm gonna WIN!
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
public class Main {
public static void main(String[] args){
System.out.println("I'm gonna WIN!\nI'm gonna WIN!\nI'm gonna WIN!");
}
}
L1-022 奇偶分家
给定N个正整数，请统计奇数和偶数各有多少个？
输入格式：
输入第一行给出一个正整N（≤1000）；第2行给出N个非负整数，以空格分隔。
输出格式：
在一行中先后输出奇数的个数、偶数的个数。中间以1个空格分隔。
输入样例：
9
88 74 101 26 15 0 34 22 77
输出样例：
3 6
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
br.readLine();
String[] str = br.readLine().split(" ");
int a=0,b=0;
for(int i=0;i<str.length;i++){
int num = Integer.parseInt(str[i]);
if(num%2==0)
a++;
else
b++;
}
System.out.println(b+" "+a);
}
}
L1-023 输出GPLT
给定一个长度不超过10000的、仅由英文字母构成的字符串。请将字符重新调整顺序，按GPLTGPLT…这样的顺序输出，并忽略其它字符。当然，四种字符（不区分大小写）的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按GPLT的顺序打印，直到所有字符都被输出。
输入格式：
输入在一行中给出一个长度不超过10000的、仅由英文字母构成的非空字符串。
输出格式：
在一行中按题目要求输出排序后的字符串。题目保证输出非空。
输入样例：
pcTclnGloRgLrtLhgljkLhGFauPewSKgt
输出样例：
GPLTGPLTGLTGLGLL
代码长度限制 16 KB 时间限制 150 ms 内存限制 64 MB
import java.io.*;
public class Main {
public static void main(String[] args) throws Exception{
BufferedReader bu = new BufferedReader(new InputStreamReader(System.in));
String str = bu.readLine().toUpperCase();
int G = 0,P=0,L=0,T=0;
for(int i=0; i<str.length(); i++) {
if(str.charAt(i) == 'G') {
G++;
} else if (str.charAt(i) == 'P') {
P++;
} else if (str.charAt(i) == 'L') {
L++;
} else if (str.charAt(i) == 'T') {
T++;
} else {
continue;
}
}
while (G > 0 || P> 0 || L> 0 || T > 0) {
if (G > 0) {
System.out.print('G');
G--;
}
if (P > 0) {
System.out.print('P');
P--;
}
if (L > 0) {
System.out.print('L');
L--;
}
if (T> 0) {
System.out.print('T');
T--;
}
}
}
}
L1-024 后天
如果今天是星期三，后天就是星期五；如果今天是星期六，后天就是星期一。我们用数字1到7对应星期一到星期日。给定某一天，请你输出那天的“后天”是星期几。
输入格式：
输入第一行给出一个正整数D（1 ≤ D ≤ 7），代表星期里的某一天。
输出格式：
在一行中输出D天的后天是星期几。
输入样例：
3
输出样例：
5
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
n=(n+2)%7;
n=n==0?7:n;
System.out.println(n);
}
}
L1-025 正整数A+B
题的目标很简单，就是求两个正整数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：
? + ? = ?
代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
String a="?",b,c;
int i,aa,bb,aint=0,bint=0;
aa=bb=0;
Scanner sc= new Scanner(System.in);
c=sc.nextLine();
if(c.charAt(0)==' ')
b = c.substring(1);
else {
String[] temps = c.split(" ",2);
a = temps[0];
b = temps[1];
}
for(i=0;i<a.length();i++) {
if(a.charAt(i)>'9'||a.charAt(i)<'0')
aa=1;
}
for(i=0;i<b.length();i++) {
if(b.charAt(i)>'9'||b.charAt(i)<'0')
bb=1;
}
if(aa==0)
aint=Integer.parseInt(a);
if(bb==0)
bint=Integer.parseInt(b);
if(aint>1000||aint<1)
aa=1;
if(bint>1000||bint<1)
bb=1;
if(aa==0&&bb==0){
System.out.println(a+" + "+b+" = "+(aint+bint));
}
else if(aa==0&&bb==1) {
System.out.println(a+" + ? = ?");
}
else if(aa==1&&bb==0) {
System.out.println("? + "+b+" = ?");
}else
System.out.println("? + ? = ?");
sc.close();
}
}
L1-026 I Love GPLT
这道超级简单的题目没有任何输入。
你只需要把这句很重要的话 —— “I Love GPLT”——竖着输出就可以了。
所谓“竖着输出”，是指每个字符占一行（包括空格），即每行只能有1个字符和回车。
输入样例：
无
输出样例：
I
L
o
v
e
G
P
L
T
注意：输出的两个空行中各有一个空格。
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
public class Main {
public static void main(String[] args) {
String c="I Love GPLT";
for(int i=0;i<c.length();i++)
System.out.println(c.charAt(i));
}
}
L1-027 出租
下面是新浪微博上曾经很火的一张图：
一时间网上一片求救声，急问这个怎么破。其实这段代码很简单，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};
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Scanner sc = new Scanner(System.in);
String cc=sc.next();
String arr="";
String index="";
int c=0;
int[] num = new int[10];
for(int i=0;i<cc.length();i++) {
num[(cc.charAt(i)-'0')]++;
}
for(int i=9;i>=0;i--) {
if(num[i]!=0) {
arr+=i+"";
c++;
}
}
for(int i=0;i<cc.length();i++) {
for(int j=0;j<c;j++) {
if(cc.charAt(i)==arr.charAt(j))
index+=j+"";
}
}
System.out.print("int[] arr = new int[]{");
for(int i=0;i<c;i++) {
System.out.print(arr.charAt(i));
if(i!=c-1)
System.out.print(",");
}
System.out.print("};\n"+"int[] index = new int[]{");
for(int i=0;i<cc.length();i++) {
System.out.print(index.charAt(i));
if(i!=cc.length()-1)
System.out.print(",");
}
System.out.println("};");
sc.close();
}
}
L1-028 判断素数
分数 10
作者 陈越
单位 浙江大学
本题的目标很简单，就是判断一个给定的正整数是否素数。
输入格式：
输入在第一行给出一个正整数N（≤ 10），随后N行，每行给出一个小于231的需要判断的正整数。
输出格式：
对每个需要判断的正整数，如果它是素数，则在一行中输出Yes，否则输出No。
输入样例：
2
11
111
输出样例：
Yes
No
代码长度限制
16 KB
时间限制
400 ms
内存限制
64 MB
L1-032 Left-pad
根据新浪微博上的消息，有一位开发者不满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) {
// TODO 自动生成的方法存根
Scanner sc =new Scanner(System.in);
int length=sc.nextInt();
String c=sc.nextLine();
c=c.charAt(1)+"";
String cc=sc.nextLine();
if(length<cc.length())
{
for(int i=0;i<length;i++){
Sysatem.out.print(cc.charAt(cc.length()-length+i));
}
}
else {
for(int i=0;i<(length-cc.length());i++)
System.out.print(c);
System.out.println(cc);
}
sc.close();
}
}
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 {
static int[] tap = new int[1001];
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
for(int i = 0;i<n;i++){
String[] str = br.readLine().split(" ");
for(int j =1;j<str.length;j++){
int item = Integer.parseInt(str[j]);
tap[item]++;
}
}
int index = 0;
for(int i=1;i<1001;i++){
if(tap[index]<=tap[i]){
index=i;
}
}
System.out.printf("%d %d\n",index,tap[index]);
br.close();
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
