【GPLT】天梯赛训练2.2

7-1 大笨钟

分数 10 作者 陈越 单位 浙江大学

微博上有个自称“大笨钟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.

#include<bits/stdc++.h>
using namespace std;
int main(){
    int x,y;
    scanf("%2d:%2d",&x,&y);
    if(x<12||x==12&&y==0){
        printf("Only %02d:%02d.  Too early to Dang.",x,y);
    }
    else{
        if(y>0) x++;
        for(int i=0;i<(x-12);i++){
            cout<<"Dang";
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

7-2 洛希极限

分数 10 作者 陈越 单位 浙江大学

科幻电影《流浪地球》中一个重要的情节是地球距离木星太近时，大气开始被木星吸走，而随着不断接近地木“刚体洛希极限”，地球面临被彻底撕碎的危险。但实际上，这个计算是错误的。

洛希极限（Roche
limit）是一个天体自身的引力与第二个天体造成的潮汐力相等时的距离。当两个天体的距离少于洛希极限，天体就会倾向碎散，继而成为第二个天体的环。它以首位计算这个极限的人爱德华·洛希命名。（摘自百度百科）

大天体密度与小天体的密度的比值开 3 次方后，再乘以大天体的半径以及一个倍数（流体对应的倍数是 2.455，刚体对应的倍数是
1.26），就是洛希极限的值。例如木星与地球的密度比值开 3 次方是 0.622，如果假设地球是流体，那么洛希极限就是 0.622×2.455=1.52701 倍木星半径；但地球是刚体，对应的洛希极限是 0.622×1.26=0.78372 倍木星半径，这个距离比木星半径小，即只有当地球位于木星内部的时候才会被撕碎，换言之，就是地球不可能被撕碎。

本题就请你判断一个小天体会不会被一个大天体撕碎。
输入格式：

输入在一行中给出 3 个数字，依次为：大天体密度与小天体的密度的比值开 3 次方后计算出的值（≤1）、小天体的属性（0 表示流体、1表示刚体）、两个天体的距离与大天体半径的比值（>1 但不超过 10）。
输出格式：

在一行中首先输出小天体的洛希极限与大天体半径的比值（输出小数点后2位）；随后空一格；最后输出 ^_ 如果小天体不会被撕碎，否则输出 T_T。
输入样例 1：

0.622 0 1.4

输出样例 1：

输入样例 2：

0.622 1 1.4

输出样例 2：

#include<bits/stdc++.h>
using namespace std;
int main(){
    double x,n,y;
    int m;
    cin>>x>>m>>n;
    if(m==0)
        y=x*2.455;
    else y=x*1.26;
    printf("%.2lf ",y);
    if(y>n) cout<<"T_T";
    else cout<<"^_^";
}
1
2
3
4
5
6
7
8
9
10
11
12
13

7-3 吃火锅

分数 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
-_-#

//①统计信息条数，即统计行数（遇到单行.不统计，退出）
//②统计包含厉害信息的条数，我们用find函数
#include<bits/stdc++.h>
using namespace std;
int main() {
	string s, s1 = "chi1 huo3 guo1";
	int x = 0, cnt = 0, first, flag = 0;
	while (1) {
		getline(cin, s);
		if (s == ".")
			break;
		x++;
		if (s.find(s1) != -1) {
			if (flag == 0) {
				flag = 1;
				first = x;
			}
			cnt++;
		}
	}
	cout << x << endl;
	if (flag != 0)
		cout << first << " " << cnt;
	else
		cout<< "-_-#" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

7-4 胎压监测

分数 15 作者 陈越 单位 浙江大学

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

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

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

输入格式：

输入在一行中给出 6 个 [0, 400] 范围内的整数，依次为 1~4 号轮胎的胎压、最低报警胎压、以及胎压差的阈值。
输出格式：

根据输入的胎压值给出对应信息：

如果不用报警，输出 Normal；
如果有一个轮胎需要报警，输出 Warning: please check #X!，其中 X 是出问题的轮胎的编号；
如果需要检查所有轮胎，输出 Warning: please check all the tires!。
1
2
3

输入样例 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!

//先找出最大值
//然后记录轮胎情况，但凡不满足两者任一条件，问题数cnt++，记录位置
//然后按照cnt数对应输出即可
#include<bits/stdc++.h>
using namespace std;
int main() {
	int a[4], x, y, cnt = 0, pos;
	for (int i = 1; i <= 4; i++)
		cin >> a[i];
	cin >> x >> y;
	int max = -1;
	for (int i = 0; i <= 4; i++) {
		if (a[i] > max)
			max = a[i];
	}
	for (int i = 1; i <= 4; i++) {
		if ((max - a[i]) > y || a[i] < x) {
			cnt++;
			pos = i;
		}
	}
	if (cnt == 0)
		cout << "Normal";
	else if(cnt==1)
		printf("Warning: please check #%d!", pos);
	else 
		printf("Warning: please check all the tires!");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

7-5 黑洞数

分数 20 作者 C课程组 单位 浙江大学

黑洞数也称为陷阱数，又称“Kaprekar问题”，是一类具有奇特转换特性的数。

任何一个各位数字不全相同的三位数，经有限次“重排求差”操作，总会得到495。最后所得的495即为三位黑洞数。所谓“重排求差”操作即组成该数的数字重排后的最大数减去重排后的最小数。（6174为四位黑洞数。）

例如，对三位数207：

第1次重排求差得：720 - 27 ＝ 693；
第2次重排求差得：963 - 369 ＝ 594；
第3次重排求差得：954 - 459 ＝ 495；
1
2
3

以后会停留在495这一黑洞数。如果三位数的3个数字全相同，一次转换后即为0。

任意输入一个三位数，编程给出重排求差的过程。
输入格式：

输入在一行中给出一个三位数。
输出格式：

按照以下格式输出重排求差的过程：

序号: 数字重排后的最大数 - 重排后的最小数 = 差值

序号从1开始，直到495出现在等号右边为止。
输入样例：

123

输出样例：

//写一个重排函数按题目输出即可
// 重排函数关键在于怎么存每个数，并排序
//注意如果一开始就给出495以及三个数字都相同的情况
#include<bits/stdc++.h>
using namespace std;
int a[3], m;
int f(int x, int& max, int& min) {
	m = 0;
	for (int i = 0; i < 4; i++)
		a[i] = 0;
	while (x) {
		a[m++] = x % 10;
		x /= 10;
	}
	sort(a, a + 3);
	max = a[2] * 100 + a[1] * 10 + a[0];
	min = a[0] * 100 + a[1] * 10 + a[2];
	return max - min;
}
int main() {
	int n, max, min;
	cin >> n;
	for (int i = 1;; i++) {
		if (!f(n, max, min) || (n == 495 && i != 1)) break;
		cout << i << ":" << " " << max << " - " << min << "=" << f(n, max, min) << endl;
		n = f(n, max, min);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

7-6 阅览室

分数 20 作者 陈越 单位 浙江大学

天梯图书阅览室请你编写一个简单的图书借阅统计程序。当读者借书时，管理员输入书号并按下S键，程序开始计时；当读者还书时，管理员输入书号并按下E键，程序结束计时。书号为不超过1000的正整数。当管理员将0作为书号输入时，表示一天工作结束，你的程序应输出当天的读者借书次数和平均阅读时间。

注意：由于线路偶尔会有故障，可能出现不完整的纪录，即只有S没有E，或者只有E没有S的纪录，系统应能自动忽略这种无效纪录。另外，题目保证书号是书的唯一标识，同一本书在任何时间区间内只可能被一位读者借阅。
输入格式：

输入在第一行给出一个正整数N（≤10），随后给出N天的纪录。每天的纪录由若干次借阅操作组成，每次操作占一行，格式为：

书号（[1, 1000]内的整数） 键值（S或E） 发生时间（hh:mm，其中hh是[0,23]内的整数，mm是[0, 59]内整数）

每一天的纪录保证按时间递增的顺序给出。
输出格式：

对每天的纪录，在一行中输出当天的读者借书次数和平均阅读时间（以分钟为单位的精确到个位的整数时间）。
输入样例：

输出样例：

//标志结束问题（遇到0结束一天）
//用两个数组存时间和借书的数量(这里用来避免故障）
//因为有n天 所以不要忘记cnt和sum的初始化
#include<bits/stdc++.h>
using namespace std;
int main() {
	int n, cnt, x, sum = 0;
	char s;
	int h, m;
	cin >> n;
	while (n--) {
		int t[1010] = { 0 }, book[1010] = { 0 };
		while (1) {
			scanf("%d %c %d:%d", &x, &s, &h, &m);
			if (x == 0)
				break;
			book[x]++;
			if (s == 'S')
				t[x] = h * 60 + m;
			else if (s == 'E' && book[x] % 2 == 0) {
				cnt++;
				t[x] = h * 60 + m - t[x];
				sum += t[x];
			}
		}
		if (cnt == 0)
			printf("0 0\n");
		else {
			printf("%d %.0f\n", cnt, sum * 1.0 / cnt);
			cnt = 0;
			sum = 0;
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

7-7 前世档案

分数 20 作者 陈越 单位 浙江大学

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

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

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

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

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

输出样例：

//本题利用二叉树的性质可以简单解决
// 类似于二分查找
//问n各问题 共有2^n个答案。左边界1，右边界2^n.
//如果是y的话，右边界变化为，mid，否则左边界变化为l+1
//最终l和r会相等
#include<bits/stdc++.h>
using namespace std;
int main() {
	int n, m;
	cin >> n >> m;
	string s;
	for (int i = 0; i < m; i++) {
		int l = 1, r = pow(2, n);
		cin >> s;
		for (int i = 0; i < n; i++) {
			int mid = (l + r) / 2;
			if (s[i] == 'y')
				r = mid;
			else
				l = mid + 1;
		}
		cout << l << endl;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

7-8 吉老师的回归

分数 15 作者 DAI, Longao 单位 杭州百腾教育科技有限公司

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

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

//本题优势字符串find函数的利用
//不过注意题目坑点，输出的是m道题的下一道题或者ak
//一个巧妙的做法是将x初始化为ak。。
//然后遍历n个字符串，如果是应该做的题，那么m--
//当m小于0的时候，即为所需结果，跳出循环
//如果都遍历完还不小于0  那么就ak了
#include<bits/stdc++.h>
using namespace std;
int main() {
    int n, m, sum = 0;
    string x = "Wo AK le";
    cin >> n >> m;
    getchar();
    for (int i = 0; i < n; i++) {
        string s;
        getline(cin, s);
        if (s.find("qiandao") == -1 && s.find("easy") == -1) {
            m--;
        }
        if (m < 0) {
            x = s;
            break;
        }
    }
    cout << x;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

7-10 连续因子

分数 20 作者 陈越 单位 浙江大学

一个正整数 N 的因子中可能存在若干连续的数字。例如 630 可以分解为 3×5×6×7，其中 5、6、7 就是 3个连续的数字。给定任一正整数 N，要求编写程序求出最长连续因子的个数，并输出最小的连续因子序列。
输入格式：

输入在一行中给出一个正整数 N（1<N<231）。 输出格式：

首先在第 1 行输出最长连续因子的个数；然后在第 2 行中按 因子1因子2……*因子k
的格式输出最小的连续因子序列，其中因子按递增顺序输出，1 不算在内。
输入样例：

630

输出样例：

3 567

//本题重点在于怎么找出最长连续因子
//我们可以以从2到n的所有数为起点，分别求出他们的最长连续因子的长度，更新最大长度，并记录起始点
//这里我们用for循环实现，j从i开始，嵌套一个while循环，在j能被tmp整除的情况下，j++，个数++
//对比最大值和个数，更新最大值
//注意输出格式
#include<bits/stdc++.h>
using namespace std;
int main() {
	long long n, temp;
	int cnt = 0, max = 0, start = 0;
	cin >> n;
	for (int i = 2; i <= sqrt(n); i++) {
		temp = n;
		cnt = 0;
		int j = i;
		while (temp % j == 0) {
			temp /= j;
			j++;
			cnt++;
		}
		if (cnt > max) {
			max = cnt;
			start = i;
		}
	}
	if (max) {
		cout << max << endl;
		for (int i = 0; i < max; i++) {
			cout << start + i;
			if (i != max - 1)
				cout << "*";
		}
	}
	else cout << "1" << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35