天梯赛训练赛题解（C++代码和Python代码）

L1-086 斯德哥尔摩火车上的题

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1518581803354341376

C++代码

#include<bits/stdc++.h> #define int long long using namespace std; string a,b; string fun(string a) { string sum; for (int i = 1; i < a.size(); i++) { if (a[i] % 2 == a[i-1] % 2) { sum += max(a[i], a[i-1]); } } return sum; } signed main() { cin>>a>>b; string u=fun(a); string v=fun(b); if(u==v){ cout<<u; } else{ cout<<u<<"\n"<<v; } return 0; }

Python代码

a=input() b=input() def fun(x): sum="" for i in range(1,len(x)): if(int(x[i])%2==int(x[i-1])%2): sum=sum+max(x[i],x[i-1]) return sum u=fun(a) v=fun(b) if(u==v): print(u,end="") else: print(u) print(v,end="")

思路

代码思路

该代码的核心目标是对两个输入字符串按指定规则处理生成新字符串，再对比两个新字符串并按规则输出结果，整体分为三个核心环节：

1. 输入获取

通过input()函数分别读取两行输入，将第一行内容赋值给变量a、第二行内容赋值给变量b，获取后续需要处理的原始字符串数据。若输入为一行两个字符串（如1234 5678），可调整为按空格拆分输入。

2. 核心处理逻辑（自定义函数fun(x)）

定义函数fun(x)处理单个字符串，生成符合规则的新字符串：

• 初始化空字符串sum，用于存储处理结果；
• 从字符串的第二个字符（索引 1）开始遍历，逐个对比当前字符（x[i]）与前一个字符（x[i-1]）；
• 将两个字符转为整数后对 2 取余，判断奇偶性是否相同：
  • 若奇偶性相同，取两个字符中更大的那个（数字字符可直接对比大小，如"9">"8"），拼接到sum中；
  • 若奇偶性不同，跳过该字符对，继续遍历；
• 遍历结束后，返回拼接完成的sum，即该字符串处理后的结果。

3. 结果判断与输出

• 调用fun()函数分别处理字符串a和b，得到两个新字符串u和v；
• 对比u和v：
  • 若两者完全相同，仅输出一次该字符串（end=""避免多余换行）；
  • 若两者不同，先输出u（自动换行），再输出v（end=""避免末尾空行）。

程序核心逻辑与流程总表

L1-087 机工士姆斯塔迪奥

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1518581903422062592

C++代码

#include <bits/stdc++.h> #define int long long using namespace std; map<int,bool>row; map<int,bool>col; int n,m,q; signed main() { cin>>n>>m>>q; while(q--) { int t,c; cin>>t>>c; if(t==0) row[c]=true; else if(t==1) col[c]=true; } int cnt=0; for(int i=1;i<=n;i++){ for(int j=1;j<=m;j++){ if(row[i]==true||col[j]==true){ continue; } else{ cnt++; } } } cout<<cnt; }

Python代码

n,m,q=map(int,input().split()) row={} col={} for i in range(0,q): t,c=map(int,input().split()) if(t==0): row[c]=True elif(t==1): col[c]=True cnt=0 for i in range(1,n+1): for j in range(1,m+1): if(row.get(i) or col.get(j)==True): continue else: cnt+=1 print(cnt,end="")

思路

代码思路

该代码的核心目标是统计 n 行 m 列网格中，未被标记行 / 列覆盖的单元格总数（被标记的行或列上的单元格不计入统计），整体逻辑分为「输入读取」「标记行 / 列」「统计有效单元格」「输出结果」四个核心环节，具体如下：

1. 输入读取：获取网格规模与操作次数

首先读取一行输入，按空格拆分为 3 个整数，分别对应网格的行数n、列数m、标记操作的次数q。这一步是后续所有操作的基础，确保能明确网格范围和需要处理的标记次数。

2. 标记行 / 列：记录被选中的行和列

初始化两个空字典row和col（字典的键用于存储行 / 列号，值设为True仅作为 “该行 / 列被标记” 的标识）。随后循环q次读取标记操作：每次读取两个整数t（操作类型）和c（行 / 列号），若t=0则标记第c行（将c作为键存入row字典），若t=1则标记第c列（将c作为键存入col字典）。

3. 统计有效单元格：遍历网格计数

初始化计数器cnt为 0，通过双层循环遍历网格的每一个单元格（外层循环遍历 1 到n的所有行，内层循环遍历 1 到m的所有列）。对每个单元格(i,j)，判断其所在行i是否在row字典中、或所在列j是否在col字典中：

• 若行 / 列被标记（字典中存在对应键），则跳过该单元格，不计数；
• 若行 / 列均未被标记，则计数器cnt加 1。这里使用dict.get()方法判断键是否存在，避免直接取值导致的KeyError（键不存在时get()返回None，不会报错）。

4. 输出结果：打印最终统计值

输出计数器cnt的值，通过end=""取消 Pythonprint函数默认的换行符，使输出格式更紧凑。

核心逻辑总结表

L1-088 静静的推荐

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1518582000729911296

C++代码

//天梯赛成绩虽然与前一个人相同，但其参加过 PAT 考试， //且成绩达到了该企业的面试分数线，则也可以接受。有多少要多少 #include <bits/stdc++.h> #define int long long using namespace std; int n,k,s; map<int,vector<int>>mp; signed main() { cin>>n>>k>>s; for(int i=0;i<n;i++){ int x,y; cin>>x>>y; mp[x].push_back(y); } int sum=0; for(auto t:mp) { vector<int>ans=t.second; if(t.first>=175) { int cnt=0; for(int i=0;i<ans.size();i++){ if(ans[i]>=s){ cnt++; } } int u=ans.size()-cnt; sum=sum+cnt+min(k,u); } } cout<<sum; }

Python代码

n,k,s=map(int,input().split()) mp={} for i in range(0,n): x,y=map(int,input().split()) if(x not in mp): mp[x]=[] mp[x].append(y) sum=0 for fir,sec in mp.items(): ans=sec if(fir>=175): cnt=0 for i in range(0,len(ans)): if(ans[i]>=s): cnt+=1 u=len(ans)-cnt sum=sum+cnt+min(k,u) print(sum)

思路

代码思路

该代码的核心目标是：统计符合条件的可接受总人数（天梯赛成绩≥175 的人群中，PAT 成绩达标者全部接受，PAT 未达标者按天梯赛同成绩组最多接受 k 人）。整体逻辑分为「输入处理」「数据分组存储」「分组筛选统计」「结果输出」四个核心环节，具体如下：

1. 输入处理：读取基础参数

首先读取一行输入，按空格拆分为 3 个整数，分别赋值给n（总人数）、k（每个天梯赛成绩组中，PAT 未达标时最多可接受的人数）、s（PAT 成绩的面试分数线）。这一步是后续所有统计的基础，明确数据规模和筛选规则。

2. 数据分组存储：按天梯赛成绩归类 PAT 成绩

初始化空字典mp，键为天梯赛成绩（整数），值为对应成绩下所有人的 PAT 成绩列表。随后循环n次读取每个人的成绩：

• 每次读取两个整数x（天梯赛成绩）、y（PAT 成绩）；
• 若x未在字典中，先初始化空列表；
• 无论x是否首次出现，都将当前 PAT 成绩y添加到mp[x]的列表中，实现 “按天梯赛成绩分组存储 PAT 成绩” 的效果。

3. 分组筛选统计：计算可接受人数

初始化计数器sum为 0，遍历字典中每个天梯赛成绩（键fir）及其对应的 PAT 成绩列表（值sec）：

• 仅处理天梯赛成绩≥175 的分组（fir >= 175），低于 175 的分组直接跳过；
• 对符合条件的分组，先统计其中 PAT 成绩≥s的人数（cnt）—— 这部分人全部可接受；
• 计算该分组中 PAT 成绩＜s的人数（u = 列表长度 - cnt），这部分人最多接受k人（取min(k, u)）；
• 将该分组的可接受人数（cnt + min(k, u)）累加到总计数器sum中。

4. 结果输出：打印总可接受人数

遍历完所有分组后，输出总计数器sum的值，即最终符合条件的可接受总人数。

核心逻辑总结表

L1-093 猜帽子游戏

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1649748772841508868

C++代码

#include<bits/stdc++.h> #define int long long using namespace std; const int N=1110; int a[N]; int b[N]; int n; signed main() { cin>>n; for(int i=0;i<n;i++){ cin>>a[i]; } int m; cin>>m; while(m--) { int cnt1=0; int cnt2=0; int cnt3=0; for(int i=0;i<n;i++){ cin>>b[i]; if(b[i]==0) cnt3++; else if(b[i]==a[i]) cnt1++; else if(b[i]!=a[i]) cnt2++; } if(cnt2==0&&cnt1>0){ cout<<"Da Jiang!!!\n"; } else{ cout<<"Ai Ya\n"; } } return 0; }

Python代码

n=int(input()) a=[] for i in input().split(): a.append(int(i)) m=int(input()) for i in range(0,m): cnt1=0 cnt2=0 cnt3=0 par=list(map(int,input().split())) for j in range(0,len(par)): x=par[j] if(x==0): cnt3+=1 elif(x==a[j]): cnt1+=1 elif(x!=a[j]): cnt2+=1 if(cnt2==0 and cnt1>0): print("Da Jiang!!!") else: print("Ai Ya")

思路

代码思路

该代码的核心目标是：对比多组查询数组与基准数组，判断每组查询是否满足 “大奖” 条件（无非 0 且与基准数组不匹配的元素，且至少有一个元素匹配）。整体逻辑分为「基准数组初始化」「读取查询次数」「逐次处理查询」「结果判断输出」四个核心环节，具体如下：

1. 基准数组初始化

首先读取整数n（数组长度），再读取一行输入并拆分为多个字符串，将每个字符串转为整数后存入列表a，构建作为对比基准的数组。这一步确保基准数组的元素类型为整数，为后续准确对比奠定基础。

2. 读取查询次数

读取整数m，表示需要进行m次数组对比查询，后续将循环m次处理每一组查询数据。

3. 逐次处理查询

对每一次查询执行以下操作：

• 初始化 3 个计数器：cnt1（查询数组与基准数组对应位置元素相等的数量）、cnt2（查询数组元素非 0 且与基准数组对应位置元素不相等的数量）、cnt3（查询数组元素为 0 的数量）；
• 读取本次查询的一行输入，拆分为字符串并转为整数列表par（即本次查询的对比数组）；
• 遍历查询数组par的每个元素，按规则更新计数器：
  • 若当前元素为 0，cnt3加 1；
  • 若当前元素与基准数组对应位置元素相等，cnt1加 1；
  • 若当前元素非 0 且与基准数组对应位置元素不相等，cnt2加 1。

4. 结果判断与输出

根据计数器结果判断是否满足 “大奖” 条件：

• 若cnt2=0（无非 0 且与基准数组不匹配的元素）且cnt1>0（至少有一个元素匹配），输出 “Da Jiang!!!”；
• 否则输出 “Ai Ya”。

核心逻辑总结表

L1-094 剪切粘贴

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1649748772841508869

C++代码

#include<bits/stdc++.h> #define int long long using namespace std; string s; signed main() { cin>>s; int n; cin>>n; for(int i=0;i<n;i++){ int x,y; cin>>x>>y; x--; y--; string u1,u2; cin>>u1>>u2; string t=s.substr(x,y-x+1); s.erase(x,y-x+1); int t1=s.find(u1); int t2=s.find(u2); if(t1==-1||t2==-1){ s.insert(s.size(),t); } else { string all=u1+u2; if(s.find(all)!=-1){ int id=s.find(all); s.insert(id+u1.size(),t); } else{ s.insert(s.size(),t); } } } cout<<s; return 0; }

Python代码

# 读取原始字符串 s = input().strip() n = int(input()) for _ in range(n): x,y,u1,u2=map(str,input().split()) x=int(x) y=int(y) # 注意：输入中的位置是从1开始计数的，需要转换为从0开始 x -= 1 y -= 1 # 提取子字符串 t = s[x:y + 1] # 删除子字符串 s = s[:x] + s[y + 1:] # 查找u1和u2 t1 = s.find(u1) t2 = s.find(u2) if t1 == -1 or t2 == -1: # 如果找不到u1或u2，添加到末尾 s += t else: all_str = u1 + u2 if s.find(all_str) != -1: # 如果找到u1和u2连在一起 id = s.find(all_str) # 在u1后面插入t s = s[:id + len(u1)] + t + s[id + len(u1):] else: # 否则添加到末尾 s += t print(s)

思路

代码思路

该代码的核心目标是：对初始字符串执行 n 次指定的子串截取 - 删除 - 插入操作（根据特定条件决定子串的插入位置）。整体逻辑分为「初始输入处理」「循环执行 n 次操作」「单次操作核心流程」「结果输出」四个核心环节，具体如下：

1. 初始输入处理

首先读取初始字符串s（去除首尾空白），再读取操作次数n，为后续 n 次字符串修改操作做准备。

2. 循环执行 n 次操作

遍历 n 次，每次完成一组 “截取 - 删除 - 查找 - 插入” 的完整操作，是代码的核心环节。

3. 单次操作核心流程

对每一次操作，按以下步骤执行：

• 参数处理与索引转换：读取本次操作的 x（起始位置）、y（结束位置）、u1（查找字符串 1）、u2（查找字符串 2）；将 x、y 从 “1 起始索引” 转为 “0 起始索引”（减 1），适配 Python 字符串的索引规则。
• 子串截取与删除：截取s中 [x, y] 区间的子串t，并从s中删除该区间的字符（通过切片拼接实现删除）。
• 条件判断与插入：
  1. 查找 u1、u2 在删除后的s中的首次出现位置（find方法，返回 - 1 表示未找到）；
  2. 若 u1 或 u2 未找到：将子串t追加到s末尾；
  3. 若 u1 和 u2 都找到：拼接u1+u2，检查该连续子串是否存在于s中；
     • 若存在：在u1+u2中 u1 的末尾位置插入t；
     • 若不存在：将t追加到s末尾。

4. 结果输出

完成 n 次操作后，打印最终修改后的字符串s。

核心逻辑总结表

L1-095 分寝室

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1649748772841508870

C++代码

#include <bits/stdc++.h> #define int long long using namespace std; int n0,n1,n; signed main() { cin>>n0>>n1>>n; int ans=1e9; int l=-1,r=-1; for(int i=1;i<=n-1;i++) { int x=i; int y=n-i; if(n0%x==0&&n1%y==0&&n0!=x&&n1!=y){ int sum=abs(n0/x-n1/y); if(sum<ans){ ans=sum; l=x; r=y; } } } if(l==-1){ cout<<"No Solution"; } else{ cout<<l<<" "<<r; } }

Python代码

n0,n1,n=map(int,input().split()) ans=1e9 l=-1 r=-1 for i in range(1,n): x=i y=n-i if(n0%x==0 and n1%y==0 and n0!=x and n1!=y): sum=abs(n0//x-n1//y) if(sum<ans): ans=sum l=x r=y if(l==-1): print("No Solution",end="") else: print(f"{l} {r}",end="")

思路

代码思路

该代码的核心目标是：找到满足条件的两个正整数 l 和 r（l+r=n），使得 n0 能被 l 整除、n1 能被 r 整除（且 n0≠l、n1≠r），且 n0/l 与 n1/r 的差值绝对值最小；若无满足条件的数，输出 “No Solution”。整体逻辑分为「输入处理」「遍历枚举候选值」「条件筛选与最优解更新」「结果输出」四个核心环节，具体如下：

1. 输入处理：读取基础参数

首先读取一行输入，按空格拆分为 3 个整数，分别赋值给n0、n1、n。其中：

• n0、n1是需要被拆分后整除的目标数；
• n是待拆分为两个正整数的总和（即 l + r = n）。同时初始化关键变量：ans（记录最小差值，初始设为极大值 1e9）、l和r（记录最优解的两个数，初始设为 - 1 表示无解）。

2. 遍历枚举候选值：拆分 n 为两个正整数

循环遍历i从 1 到 n-1（确保拆分的两个数都是正整数，且 i + (n-i) = n），每次将n拆分为x=i和y=n-i，作为一组候选的 (l, r) 组合。

3. 条件筛选与最优解更新

对每组候选值 (x, y)，先判断是否满足核心条件：

• n0 % x == 0：n0 能被 x 整除；
• n1 % y == 0：n1 能被 y 整除；
• n0 != x且n1 != y：排除 n0 等于 x、n1 等于 y 的情况。若满足所有条件，计算n0//x与n1//y的差值绝对值sum：
• 若sum小于当前记录的最小差值ans，则更新ans为该差值，并记录当前的 x、y 为最优解（l=x，r=y）。

4. 结果输出：判断是否有解并打印

遍历结束后，若l仍为初始值 - 1（无满足条件的组合），输出 “No Solution”；否则输出最优解的 l 和 r。

核心逻辑总结表

L1-096 谁管谁叫爹

https://pintia.cn/problem-sets/994805046380707840/exam/problems/type/7?problemSetProblemId=1649748772841508871

C++代码

#include <bits/stdc++.h> #define int long long using namespace std; int n; int fun(int x) { int sum=0; while(x) { int u=x%10; sum+=u; x/=10; } return sum; } signed main() { cin>>n; for(int i=0;i<n;i++){ int na,nb; cin>>na>>nb; int sa=fun(na); int sb=fun(nb); if((na%sb==0&&nb%sa==0)||(na%sb&&nb%sa)) { if(na>nb) cout<<"A\n"; else cout<<"B\n"; } else { if(na%sb==0) cout<<"A\n"; if(nb%sa==0) cout<<"B\n"; } } }

Python代码

n=int(input()) def fun(x): sum=0 while(x): u=x%10 sum+=u x=x//10 return sum for i in range(0,n): na,nb=map(int,input().split()) sa=fun(na) sb=fun(nb) if((na%sb==0 and nb%sa==0)or(na%sb and nb%sa)): if(na>nb): print("A") else: print("B") else: if(na%sb==0): print("A") if(nb%sa==0): print("B")

思路

代码思路

该代码的核心目标是：对 n 组输入的整数对 (na, nb)，先计算两数的数位和（sa 为 na 的数位和，sb 为 nb 的数位和），再根据 na、nb 分别对对方数位和的整除性规则，判断输出 "A" 或 "B"。整体逻辑分为「数位和计算函数定义」「输入处理与循环」「整除性判断与结果输出」三个核心环节，具体如下：

1. 数位和计算函数：fun (x)

定义函数fun(x)，用于计算整数x的 “数位和”（即 x 的每一位数字相加的结果）：

• 初始化计数器sum为 0；
• 通过循环逐位提取x的个位数字：u = x % 10，将u累加到sum；
• 去掉x的个位数字：x = x // 10，直到x变为 0（所有数位处理完毕）；
• 返回最终的数位和sum。

2. 输入处理与循环：读取 n 组数据

首先读取整数n（表示需要处理的数对组数），然后循环n次，每次读取一组输入的两个整数na和nb，并调用fun()分别计算na的数位和sa、nb的数位和sb。

3. 整除性判断与结果输出

对每组 (na, nb, sa, sb)，分两层规则判断输出结果：

• 第一层判断：若满足「na 能被 sb 整除 且 nb 能被 sa 整除」或「na 不能被 sb 整除 且 nb 不能被 sa 整除」（即两者整除性状态一致）：
  • 比较 na 和 nb 的大小，na 更大则输出 "A"，否则输出 "B"；
• 第二层判断（第一层不满足时）：
  • 若 na 能被 sb 整除，输出 "A"；
  • 若 nb 能被 sa 整除，输出 "B"。

核心逻辑总结表