在这里插入图片描述

题目汇总

题解
- L1-071 前世档案
- L1-072 刮刮彩票
- L1-073 人与神
- L1-074 两小时学完C语言
- L1-075 强迫症
- L1-076 降价提醒机器人
- L1-077 大笨钟的心情
- L1-078 吉老师的回归
- L1-079 天梯赛的善良
- L1-080 乘法口诀数列
写在最后

题解

L1-071 前世档案

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

现在我们把结论从左到右顺序编号，编号从 1 开始。这里假设回答都是简单的“是”或“否”，又假设回答“是”对应向左的路径，回答“否”对应向右的路径。给定玩家的一系列回答，请你返回其得到的结论的编号。

输入格式：
输入第一行给出两个正整数：N（≤30）为玩家做一次测试要回答的问题数量；M（≤100）为玩家人数。

随后 M 行，每行顺次给出玩家的 N 个回答。这里用 y 代表“是”，用 n 代表“否”。

输出格式：
对每个玩家，在一行中输出其对应的结论的编号。

输入样例：
3 4
yny
nyy
nyn
yyn
输出样例：
3
5
6
2

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m;
    int sum;
    while(m--)
    {
    	sum=pow(2,n);
        char s[n];
        cin>>s;
        for(int i=0;i<n;i++)
        {
            if(s[i]=='y')
                sum-=pow(2,n-i-1);
        }
        cout<<sum<<endl;
    }
}

L1-072 刮刮彩票

“刮刮彩票”是一款网络游戏里面的一个小游戏。如图所示：
在这里插入图片描述
每次游戏玩家会拿到一张彩票，上面会有 9 个数字，分别为数字 1 到数字 9，数字各不重复，并以 3×3 的“九宫格”形式排布在彩票上。

在游戏开始时能看见一个位置上的数字，其他位置上的数字均不可见。你可以选择三个位置的数字刮开，这样玩家就能看见四个位置上的数字了。最后玩家再从 3 横、3 竖、2 斜共 8 个方向中挑选一个方向，方向上三个数字的和可根据下列表格进行兑奖，获得对应数额的金币。
在这里插入图片描述
现在请你写出一个模拟程序，模拟玩家的游戏过程。

输入格式:
输入第一部分给出一张合法的彩票，即用 3 行 3 列给出 0 至 9 的数字。0 表示的是这个位置上的数字初始时就能看见了，而不是彩票上的数字为 0。

第二部给出玩家刮开的三个位置，分为三行，每行按格式 x y 给出玩家刮开的位置的行号和列号（题目中定义左上角的位置为第 1 行、第 1 列。）。数据保证玩家不会重复刮开已刮开的数字。

最后一部分给出玩家选择的方向，即一个整数： 1 至 3 表示选择横向的第一行、第二行、第三行，4 至 6 表示纵向的第一列、第二列、第三列，7、8分别表示左上到右下的主对角线和右上到左下的副对角线。

输出格式:
对于每一个刮开的操作，在一行中输出玩家能看到的数字。最后对于选择的方向，在一行中输出玩家获得的金币数量。

输入样例:
1 2 3
4 5 6
7 8 0
1 1
2 2
2 3
7
输出样例:
1
5
6
180

#include<bits/stdc++.h>
using namespace std;
int vis[10];
int main() {
	int g[4][4];
	int c[4][2];
	int d;
	int s[25]={0,0,0,0,0,0,10000,36,720,360,80,252,108,72,54,180,72,180,119,36,306,1080,144,1800,3600};
	int flagi,flagj;
	int sum=0;
	for(int i=1; i<=3; ++i) {
		for(int j=1; j<=3; ++j) {
			cin >> g[i][j];
			if(g[i][j] == 0) {
				c[0][0]=i;
				c[0][1]=j;
			}
            else
			vis[g[i][j]] = true;
		}
	}
	for(int i=1; i<=9; i++) {
		if(!vis[i]) {
			g[c[0][0]][c[0][1]] = i;
			break;
		}
	}
	for(int i=1; i<=3; ++i) {
		cin >> c[i][0] >> c[i][1];
		cout << g[c[i][0]][c[i][1]] << endl;
	}
	cin >> d;
	if(d == 1) {
		for(int i=1; i<=3; ++i) {
			sum += g[1][i];
		}
	} else if(d == 2) {
		for(int i=1; i<=3; ++i) {
			sum += g[2][i];
		}
	} else if(d == 3) {
		for(int i=1; i<=3; ++i) {
			sum += g[3][i];
		}
	} else if(d == 4) {
		for(int i=1; i<=3; ++i) {
			sum += g[i][1];
		}
	} else if(d == 5) {
		for(int i=1; i<=3; ++i) {
			sum += g[i][2];
		}
	} else if(d == 6) {
		for(int i=1; i<=3; ++i) {
			sum += g[i][3];
		}
	} else if(d == 7) {
		for(int i=1; i<=3; ++i) {
			sum += g[i][i];
		}
	} else if(d == 8) {
		for(int i=1; i<=3; ++i) {
			sum += g[i][4-i];
		}
	}
	cout << s[sum] << endl;
	return 0;
}

L1-073 人与神

跨界大神 L. Peter Deutsch 有一句名言：“To iterate is human, to recurse divine.”（迭代的是人，递归的是神）。本题就请你直接在屏幕上输出这句话。

输入格式：
本题没有输入。

输出格式：
在一行中输出 To iterate is human, to recurse divine.。

输入样例：
无
输出样例：
To iterate is human, to recurse divine.

#include<bits/stdc++.h>
using namespace std;
int main()
{
    cout<<"To iterate is human, to recurse divine.";
}

L1-074 两小时学完C语言

在这里插入图片描述
知乎上有个宝宝问：“两个小时内如何学完 C 语言？”当然，问的是“学完”并不是“学会”。

假设一本 C 语言教科书有 N 个字，这个宝宝每分钟能看 K 个字，看了 M 分钟。还剩多少字没有看？

输入格式：
输入在一行中给出 3 个正整数，分别是 N（不超过 400 000），教科书的总字数；K（不超过 3 000），是宝宝每分钟能看的字数；M（不超过 120），是宝宝看书的分钟数。

题目保证宝宝看完的字数不超过 N。

输出格式：
在一行中输出宝宝还没有看的字数。

输入样例：
100000 1000 72
输出样例：
28000

#include<iostream>
using namespace std;
int main()
{
    int a,b,c;
    cin>>a>>b>>c;
    cout<<a-b*c;
}

L1-075 强迫症

小强在统计一个小区里居民的出生年月，但是发现大家填写的生日格式不统一，例如有的人写 199808，有的人只写 9808。有强迫症的小强请你写个程序，把所有人的出生年月都整理成年年年年-月月格式。对于那些只写了年份后两位的信息，我们默认小于 22 都是 20 开头的，其他都是 19 开头的。

输入格式：
输入在一行中给出一个出生年月，为一个 6 位或者 4 位数，题目保证是 1000 年 1 月到 2021 年 12 月之间的合法年月。

输出格式：
在一行中按标准格式年年年年-月月将输入的信息整理输出。

输入样例 1：
9808
输出样例 1：
1998-08
输入样例 2：
0510
输出样例 2：
2005-10
输入样例 3：
196711
输出样例 3：
1967-11

#include<bits/stdc++.h>
using namespace std;
int main()
{
	string s;
	cin>>s;
	if(s.size()==4)
	{
		if( (s[0]-'0')*10+(s[1]-'0')>21 )
			printf("19");
		else
			printf("20");
		printf("%c%c-%c%c",s[0],s[1],s[2],s[3]);
	}
	else
	{
		for(int i=0;i<s.size();i++)
		{
			cout<<s[i];
			if(i==3)
			{
				cout<<"-";
			}
		}
	}
	
}

L1-076 降价提醒机器人

小 T 想买一个玩具很久了，但价格有些高，他打算等便宜些再买。但天天盯着购物网站很麻烦，请你帮小 T 写一个降价提醒机器人，当玩具的当前价格比他设定的价格便宜时发出提醒。

输入格式：
输入第一行是两个正整数 N 和 M (1≤N≤100,0≤M≤1000)，表示有 N 条价格记录，小 T 设置的价格为 M。

接下来 N 行，每行有一个实数 P
i

（−1000.0<P
i

<1000.0），表示一条价格记录。

输出格式：
对每一条比设定价格 M 便宜的价格记录 P，在一行中输出 On Sale! P，其中 P 输出到小数点后 1 位。

输入样例：
4 99
98.0
97.0
100.2
98.9
输出样例：
On Sale! 98.0
On Sale! 97.0
On Sale! 98.9

#include<iostream>
using namespace std;
int main()
{
    int n,price;
    double sale;
    cin>>n>>price;
    for(int i=1;i<=n;i++)
    {
        cin>>sale;
        if(sale<price)
            printf("On Sale! %.1lf\n",sale);
    }
}

L1-077 大笨钟的心情

在这里插入图片描述
有网友问：未来还会有更多大笨钟题吗？笨钟回复说：看心情……

本题就请你替大笨钟写一个程序，根据心情自动输出回答。

输入格式：
输入在一行中给出 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

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int clock[24], n = 0;
	for (int i = 0; i < 24; i++)
	{
		cin>>clock[i];
	}
	cin>>n;
	while (n >= 0 && n <= 23)
	{
		if (clock[n] > 50)
			printf("%d Yes\n", clock[n]);
		else
			printf("%d No\n", clock[n]);
		cin>>n;
	}
    return 0;
}

L1-078 吉老师的回归

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

为了简化题目，我们不妨假设天梯赛的每道题目可以用一个不超过 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

#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n,m,count=0;
	string s1,s2;    
	cin>>n>>m; 
	getchar();
	for(int i=1;i<=n;i++)
	{
		getline(cin,s1);
		if(s1.find("qiandao")==-1&&s1.find("easy")==-1)   
		{
			count++;          
			if(count>m)                  
			{
				s2=s1; 
                
			}                                       
        }          
	} 
	if(count<=m)
           printf("Wo AK le");  
    else
           cout<<s2;      	
}

L1-079 天梯赛的善良

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

于是命题组首先将编程能力划分成了 10
6
个等级（太疯狂了，这是假的），然后调查了每个参赛学生的编程能力。现在请你写个程序找出所有参赛学生的最小和最大能力值，给命题组作为出题的参考。

输入格式：
输入在第一行中给出一个正整数 N（≤2×10
4
），即参赛学生的总数。随后一行给出 N 个不超过 10
6
的正整数，是参赛学生的能力值。

输出格式：
第一行输出所有参赛学生的最小能力值，以及具有这个能力值的学生人数。第二行输出所有参赛学生的最大能力值，以及具有这个能力值的学生人数。同行数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：
10
86 75 233 888 666 75 886 888 75 666
输出样例：
75 3
888 2

#include<iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    int ability;
    int max=0,min=9999999;
    int a[100100];
    int count1=0,count2=0;
    for(int i=1;i<=n;i++)
    {
        cin>>ability;
        a[i]=ability;
        if(max<ability)
            max=ability;
        if(min>ability)
            min=ability;
            
    }
    for(int i=1;i<=n;i++)
    {
        if(a[i]==max)
            count1++;
        if(a[i]==min)
            count2++;
    }
    cout<<min<<" "<<count2<<endl<<max<<" "<<count1; 
}

L1-080 乘法口诀数列

本题要求你从任意给定的两个 1 位数字 a
1

和 a
2

开始，用乘法口诀生成一个数列 {a
n

}，规则为从 a
1

开始顺次进行，每次将当前数字与后面一个数字相乘，将结果贴在数列末尾。如果结果不是 1 位数，则其每一位都应成为数列的一项。

输入格式：
输入在一行中给出 3 个整数，依次为 a
1

、a
2

和 n，满足 0≤a
1

,a
2

≤9，0<n≤10
3
。

输出格式：
在一行中输出数列的前 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 后结束。

#include<iostream>
using namespace std;
int main()
{
	int a1,a2,n;
    int count = 3, num[1001];
    int sum;
    cin>>a1>>a2>>n;
    num[1] = a1, num[2] = a2;
	for (int i = 1; i <= n; i++)
	{
		sum = num[i] * num[i + 1];
		if (sum < 10)
		{
			num[count++] = sum;
		}
		else
		{
			num[count++] = sum / 10;
			num[count++] = sum % 10;
		}
		if (count > n)
			break;
	}
	cout<<a1;
	for (int i = 2; i <= n; i++) 
	{
		cout<<" "<<num[i];
	}
    return 0;
}