团队天梯赛练习题题解 L1-041~L1-050

L1-041 寻找250 (10 分)

对方不想和你说话，并向你扔了一串数…… 而你必须从这一串数字中找到“250”这个高大上的感人数字。

输入格式

输入在一行中给出不知道多少个绝对值不超过 $1000$ 的整数，其中保证至少存在一个“ $250$ ”。

输出格式

在一行中输出第一次出现的“ $250$ ”是对方扔过来的第几个数字（计数从 $1$ 开始）。题目保证输出的数字在整型范围内。

输入样例

888 666 123 -233 250 13 250 -222

输出样例

PotremZ の C++ 解決策

#include<cstdio>
using namespace std;
int main(){
	int x,cnt=0;
	while(scanf("%d",&x)!=EOF&&x!=250){
		++cnt;
	}
	printf("%d",cnt+1);
	return 0;
}

winterl の Python 解決策

# 先根据空格分割成整数数组，然后直接用 index 查就好（记得索引要 + 1）
print(1 + input().split().index("250"))

# numbers = input().split()
# index = 1 + numbers.index("250")
# print(index)

L1-042 日期格式化 (5 分)

世界上不同国家有不同的写日期的习惯。比如美国人习惯写成“月-日-年”，而中国人习惯写成“年-月-日”。下面请你写个程序，自动把读入的美国格式的日期改写成中国习惯的日期。

输入格式

输入在一行中按照“mm-dd-yyyy”的格式给出月、日、年。题目保证给出的日期是1900年元旦至今合法的日期。

输出格式

在一行中按照“yyyy-mm-dd”的格式给出年、月、日。

输入样例

03-15-2017

输出样例

2017-03-15

PotremZ の C++ 解決策

#include<cstdio>
using namespace std;
int main(){
	int mm,dd,yyyy;
	scanf("%d-%d-%d",&mm,&dd,&yyyy);
	printf("%04d-%02d-%02d",yyyy,mm,dd);
	return 0;
}

winterl の Python 解決策

# 这里可以给 split 传参数 让他以 - 来分割
month, day, year = input().split("-")
# 然后格式化字符拼接就好了
print(f"{year}-{month}-{day}")

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

PotremZ’s Solution

题目保证书号是书的唯一标识，同一本书在任何时间区间内只可能被一位读者借阅；也就是说，不用担心会出现一个人借了一本书，在没有还的情况下，还有人来借这本书；
时间可以从00:00开始，所以记录某本书是否被借出的状态，不能单纯以它在哪个时刻被借出，因为其可能在0时刻就被人借出；在我的代码中，使用了将vis数组全部初始为-1的做法，来表示其没有被借出；
在一行中输出当天的读者借书次数和平均阅读时间（以分钟为单位的精确到个位的整数时间），在样例当中其实还有隐含条件，即平均阅读时间要四舍五入；

PotremZ の C++ 解決策

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
int n,num,hh,mm,readers,nowtime,day,vis[1005];
char key;
int main(){
	scanf("%d",&n);
	
	memset(vis,-1,sizeof(vis));
	
	while(day<n){
		scanf("%d %c %d:%d",&num,&key,&hh,&mm);
		if(num==0){
			printf("%d %.0lf\n",readers,readers==0 ? 0 : round(1.0*nowtime/readers));
			++day;
			memset(vis,-1,sizeof(vis));
			readers=nowtime=0;
			continue;
		}
		
		if(key=='S')
			vis[num]=hh*60+mm;
		
		
		if(key=='E'){
			if(vis[num]==-1) continue;
			nowtime+=hh*60+mm-vis[num];
			++readers;
			vis[num]=-1;
		}
	}
	return 0;
}

winterl の Python 解決策

from collections import defaultdict

day = int(input())

is_borrowd = defaultdict(bool) # 是否被借出
borrowd = defaultdict(int) # 借出时间
borrowd_counter = 0 # 借出次数


def is_ok(book_id, option): # 是否为合法操作
    return (option == "S" and not is_borrowd[book_id]) or (
        option == "E" and is_borrowd[book_id]
    )


def count_time(book_id, option, time): # 计算借书时间
    hour, minute = map(int, time.split(":"))
    minutes = hour * 60 + minute
    # 如果操作非法
    if not is_ok(book_id, option):
        if option == "S": # 按照最新的一次借
            borrowd[book_id] = minutes
        return 0 # 借书没有时间贡献
    if option == "S":
        is_borrowd[book_id] = True
        borrowd[book_id] = minutes
        return 0
    # 还书时
    is_borrowd[book_id] = False
    # 函数里对全局栈变量进行修改，需要用 global
    global borrowd_counter
    borrowd_counter += 1
    return minutes - borrowd[book_id]


total = 0
while day > 0:
    book_id, option, time = input().split()
    if book_id != "0":
        total += count_time(book_id, option, time)
        continue
    # 出现 0 后这一天就过去了
    day -= 1
    if borrowd_counter == 0:
        print(0, 0)
    else: # 注意哈 这里是四舍五入，不是向上取整
        print(borrowd_counter, f"{total / borrowd_counter:.0f}")
    # 记得重新初始化
    total, borrowd_counter = 0, 0
    borrowd.clear()
    is_borrowd.clear()

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

PotremZ の C++ 解決策

#include<iostream>
#include<map>
using namespace std;
map<string,string>mp;
int main(){
	mp["ChuiZi"]="Bu";
	mp["JianDao"]="ChuiZi";
	mp["Bu"]="JianDao";
	int k,cnt=0; string s;
	scanf("%d",&k);
	while(cin>>s&&s!="End"){
		++cnt;
		if(cnt==k+1) cnt=0,cout<<s<<endl;
		else cout<<mp[s]<<endl;
	}
	return 0;
}

winterl の Python 解決策

cycle = int(input()) # 循环周期
current = 0
while True:
    option = input()
    if option == "End":
        break
    # 判断是否到周期 到就平局
    if current == cycle:
        current = 0
        print(option)
        continue
    current += 1
    # match 语句进行模式匹配 （可以用 if-elif-else）
    match option:
        case "ChuiZi":
            print("Bu")
        case "Bu":
            print("JianDao")
        case "JianDao":
            print("ChuiZi")

L1-045 宇宙无敌大招呼 (5 分)

据说所有程序员学习的第一个程序都是在屏幕上输出一句“Hello World”，跟这个世界打个招呼。作为天梯赛中的程序员，你写的程序得高级一点，要能跟任意指定的星球打招呼。

输入格式

输入在第一行给出一个星球的名字S，是一个由不超过7个英文字母组成的单词，以回车结束。

输出格式

在一行中输出Hello S，跟输入的S星球打个招呼。

输入样例

Mars

输出样例

Hello Mars

PotremZ の C++ 解決策

#include<iostream>
using namespace std;
int main(){
	string s;
	cin>>s;
	cout<<"Hello "<<s<<endl;
	return 0;
}

winterl の Python 解決策

# fstring中可以使用函数，也可以使用其他格式化字符串
print(f"Hello {input()}")

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

PotremZ’s Solution

思路来自倪倪倪倪倪~的L1-046. 整除光棍

可以看出，long long类型都不足以满足本题的要求，所以这里要模拟出高精度除低精度的算法；
可以不用将高精度的、全为 $1$ 的数预处理出来，而是转换一种思路；
考虑模拟除法竖式；
先将能除x的1数串处理出来，因为x $<1000$ ，所以能除x的1数串一定也不超过 $1111$ ；
题目保证能整除，所以在找到能除开x的1数串后，模拟除法竖式，知道除尽为止，即为答案；

PotremZ の C++ 解決策

#include<cstdio>
#include<iostream>
using namespace std;
int x,cnt,now;
bool f;
string ans,tmp;
int main(){
	scanf("%d",&x);
	while(1){
		now=now*10+1; ++cnt;
		if(f || now/x){
			f=1;
			tmp=now/x+'0';
			ans=ans+tmp;
		}
		if((now%=x)==0){
			cout<<ans<<" ";
			printf("%d",cnt);
			return 0;
		}
	}
	return 0;
}

winterl の Python 解決策

x = int(input())
current, length = 1, 1
# 直接枚举 1 的位数，py自带高精度，可以很方便
while current % x != 0:
    current *= 10
    current += 1
    length += 1
# 这里记得整除
print(current // x, length)

L1-047 装睡 (10 分)

你永远叫不醒一个装睡的人 —— 但是通过分析一个人的呼吸频率和脉搏，你可以发现谁在装睡！医生告诉我们，正常人睡眠时的呼吸频率是每分钟 $15-20$ 次，脉搏是每分钟 $50-70$ 次。下面给定一系列人的呼吸频率与脉搏，请你找出他们中间有可能在装睡的人，即至少一项指标不在正常范围内的人。

输入格式

输入在第一行给出一个正整数 $N(≤10)$ 。随后 $N$ 行，每行给出一个人的名字（仅由英文字母组成的、长度不超过 $3$ 个字符的串）、其呼吸频率和脉搏（均为不超过 $100$ 的正整数）。

输出格式

按照输入顺序检查每个人，如果其至少一项指标不在正常范围内，则输出其名字，每个名字占一行。

输入样例

4
Amy 15 70
Tom 14 60
Joe 18 50
Zoe 21 71

输出样例

Tom
Zoe

PotremZ の C++ 解決策

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
string name;
int n,H,M;
int main(){
	scanf("%d",&n);
	while(n--){
		cin>>name; scanf("%d %d",&H,&M);
		if(H<15 || 20<H || M<50 || 70<M) cout<<name<<endl;
	}
	return 0;
}

winterl の Python 解決策

for _ in range(int(input())):
    name, frequency, pulse = input().split()
    # 反向条件，如果合法就跳过
    if (15 <= int(frequency) <= 20) and (50 <= int(pulse) <= 70):
        continue
    print(name)

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

PotremZ の C++ 解決策

#include<cstdio>
using namespace std;
int Ra,Ca,Rb,Cb,A[105][105],B[105][105];
int main(){
	scanf("%d %d",&Ra,&Ca);
	for(int i=1;i<=Ra;++i)
		for(int j=1;j<=Ca;++j)
			scanf("%d",&A[i][j]);
	scanf("%d %d",&Rb,&Cb);
	for(int i=1;i<=Rb;++i)
		for(int j=1;j<=Cb;++j)
			scanf("%d",&B[i][j]);
	if(Ca!=Rb) printf("Error: %d != %d",Ca,Rb);
	else {
		printf("%d %d\n",Ra,Cb);
		for(int i=1;i<=Ra;++i)
			for(int j=1;j<=Cb;++j){
					int C=0;
					for(int k=1;k<=Ca;++k)
						C+=A[i][k]*B[k][j];
					printf("%d%c",C,j==Cb ? '\n' : ' ');
				}
		
	}
	return 0;
}

winterl の Python 解決策

row_of_a, column_of_a = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(row_of_a)]
row_of_b, column_of_b = map(int, input().split())
b = [list(map(int, input().split())) for _ in range(row_of_b)]
# 矩阵不能乘
if column_of_a != row_of_b:
    print(f"Error: {column_of_a} != {row_of_b}")
    exit(0)
# 初始化答案矩阵
matrix = [[0 for _ in range(column_of_b)] for _ in range(row_of_a)]
# 矩阵乘法可以自己去看看原理，线性代数
for i in range(row_of_a):
    for j in range(column_of_a):
        for k in range(column_of_b):
            matrix[i][k] += a[i][j] * b[j][k]
# 打印
print(row_of_a, column_of_b)
for line in matrix:
    print(*line)

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

PotremZ’s Solution

这显然是个大模拟；
以现在这个座位应该让谁坐为思考点，使用queue队列来维护这个座位要让哪个学校的哪个人坐；
那么特殊的地方，在只剩下最后一个队伍的时候，判断出其为最后一队后，现在的座位就要每次往后调两个（注意代码中f变量，因为这个判断其实还要再特判一次）；

PotremZ の C++ 解決策

#include<cstdio>
#include<queue>
using namespace std;
int n,TeamSize[105],Num[105][105],tmp,nowTeam,nowSize[105];
bool Finish[105],f;
queue<int>q;
bool check(){
	int res=0;
	for(int i=1;i<=n;++i) if(!Finish[i]) ++res;
	if(res==1) return 1;
	else return 0;
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i){
		q.push(i);
		scanf("%d",&TeamSize[i]);
		TeamSize[i]*=10;
	}
	while(!q.empty()){
		if(!check()) ++tmp;
		else{
			if(f) tmp+=2;
			else f=1,++tmp;
		}
		nowTeam=q.front(); q.pop();
		Num[nowTeam][++nowSize[nowTeam]]=tmp;
		if(nowSize[nowTeam]<TeamSize[nowTeam]) q.push(nowTeam); 
		else Finish[nowTeam]=1;
	}
	for(int i=1;i<=n;++i){
		printf("#%d\n",i);
		for(int j=1;j<=TeamSize[i];++j)
			printf("%d%c",Num[i][j],j%10==0 ? '\n' : ' ');
	}
	return 0;
}

winterl の Python 解決策

# 一道非常恶心的模拟
n = int(input())
counts = list(map(int, input().split()))
# 我们用动态列表存下来每个学校中队伍，这里我们不用管一行十个数字，先选出来全部的
tables = [[] for _ in range(n)]
# selectd_school 用于选择添加到哪个学校 （0索引）
selectd_school = 0
max_team_id = sum(counts) * 10 # 填充到的目标值（最大的队伍号）
for team_id in range(1, max_team_id + 1): # 按照顺序暴力填号
    # 循环找到一个可以安排座位的学校，当前学校不一定可以安排位置
    while counts[selectd_school] * 10 == len(tables[selectd_school]):
        selectd_school = (selectd_school + 1) % n
    tables[selectd_school].append(team_id) # 叫他去这个学校
    selectd_school = (selectd_school + 1) % n # 去下一个学校
# 回溯到上一个学校，因为会多移位一次
selectd_school = (selectd_school + n - 1) % n
# 记录最大队伍数
max_count = counts[selectd_school]
# 找到第二大的队伍数
counts[selectd_school] = 0 # 可能只有一个队伍，所以最好改成 0
new_max_count = max(counts)
# 如果最大的两个学校的队伍数不同 或 只有一个学校，那么就特化间隔就座的的编号
if max_count != new_max_count or n == 1:
    # 看看是从哪里开始需要特化，算出离终点的偏移量
    offset = 10 * (max_count - new_max_count)
    start = max_team_id - offset # 计算开始值，先求开始值的前置队伍
    # 坑点！如果开始值的前置队伍已经在这个学校了，需要间隔就座
    start += 2 if start in tables[selectd_school] else 1
    # 刷新座位表的间隔就座开始位置值
    tables[selectd_school][-offset] = start
    # 利用负索引的便捷，快速更新数，间隔为 2
    for index in range(-offset + 1, 0): # 这里 + 1 是因为已经处理开始位置了
        tables[selectd_school][index] = 2 + tables[selectd_school][index - 1]

# 打印数据表，用 zip 快速整合学校编号和座位表
for school, table in zip(range(1, n + 1), tables):
    print(f"#{school}") # 格式化字符串 先打学校号
    # 这里可以用切片的方法，循环将一维列表打成矩阵
    for start in range(0, len(table), 10):
        # 每 10 个元素一行
        print(*table[start : start + 10])

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

PotremZ’s Solution

可以将字符串视为 $26$ 进制数，其中a $=25$ 、z $=0$ ；
将答案先填满前置零（a），随后将 $N$ 转换为这个 $26$ 进制数即可；

PotremZ の C++ 解決策

#include<cstdio>
#include<map>
#include<iostream>
using namespace std;
map<int,char>mp;
int L,N;
string ans;
int main(){
	char x='a'-1;
	for(int i=25;~i;--i) mp[i]=++x;
	scanf("%d %d",&L,&N); N--;
	for(int i=0;i<L;++i) ans=ans+"z";
	int tmp=L-1;
	while(N){
		ans[tmp]=mp[N%26];
		N/=26;
		--tmp;
	}
	cout<<ans<<endl;
	return 0;
}

winterl の Python 解決策

# 看到第一反应容易想到模拟，求全排列
# 其实可以想到进制转换，这个就是 Excel 表格的编号嘛
# 理解成 26 进制，a 就是 0，z 就是 25，姑且让我叫他为 Excel 进制
# 问 L 位 Excel 进制中，最大值减去 N 的结果
# 将这个结果用 Excel 进制打印出来

length, offset = map(int, input().split())
# 容易想到，length 位 10 进制最大值是 length 个 9 即 10**length - 1
# 那么 length 位 Excel 进制最大值就是 length 个 z 即 26**length - 1

max_value = 26**length - offset  # 倒数 offset 个，就是这个数减去 offset
digits = []
# 坑点！要补前导 a 的哈
for _ in range(length):
    # 数字转回字符串
    max_value, digit = divmod(max_value, 26)
    digits.append(chr(ord("a") + digit))
# 列表是倒序存储了每个位，记得倒转
print("".join(digits[::-1]))

题解

#团队天梯赛练习题

团队天梯赛练习题题解 L1-041~L1-050

https://winterl-blog.netlify.app/2025/01/20/团队天梯赛练习题题解 L1-041~L1-050/

作者

PotremZ, winterl

发布于

2025年1月20日

许可协议

团队天梯赛练习题题解 L1-051~L1-060 上一篇

团队天梯赛练习题题解 L1-031~L1-040 下一篇