目录
小码哥的开心数字
淘金者
捡麦子
小码哥玩游戏
手机测试
自动浇花机
买月饼
未来战争
双人成行
魔法水晶球
编辑自驾游
文章压缩
银河贸易市场
小码哥的开心数字
子难度：青铜
0时间限制：1秒
巴占用内存：64M
小码哥有超能力，他总是能自动的将数字反过来，123转换后321,439转换后34，但是如果反转过
后的数小于反转前的数，小码哥会特别不开心，小码哥现在有个数字，请你判断一下这个数字
会让他开心吗？
格式
输入格式：一行一个整数n(1≤n≤100000)表示反转前的数。
输出格式：第一行反转后的数；
第二行判断反转后的数是否是小码哥的开心数字（开心数字为Tue，不开心数
字为False)。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,n2,temp;
cin >>n;
temp=n;
while (n) {
n2 = n2 * 10 + n % 10;
n /= 10;
}
cout <<n2 <<endl;
if(n2<temp)
cout <<"False";
else
cout <<"True";
return 0;}
淘金者
号难度：青铜
0时间限制：1秒
巴占用内存：64M
小码哥是一个数字世界的淘金者，他会在给定的字符串“金矿”中找到第一个“金子（特定字符）”
的位置，如he1lo”中找“o”,他能很快找到“o的位置5，但是有一天他突然失去了这个能力，小
码哥找不到“金子”的位置了，你能帮他吗（若没有金子则返回-1)？
格式
输入格式：第一行一个长度为s(1≤s≤10)的字符串表示要搜索的“金矿”；
第二行一个字符c表示要寻找的"金子”字符。
输出格式：一行一个整数表示“金子”字符的位置（第一个位置算1，若没有金子则返
回-1)。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
char c;
cin>>s>>c;
for (int i=0;i<s.length();i++)
if (s[i]==c){
cout <<i + 1;
return 0;
}
cout<<-1;
return 0;
}
捡麦子
难度：青铜
0时间限制：1秒
巴占用内存：64M
小码哥是一个农民，他有一大块麦田，麦子丰收时他需要去捡拾麦子，麦田里第1米有1个麦子，之
后麦田里第n(1<n≤1000)米有n+(n-1)+..+1个麦子，如第1米有1个麦子，第
2米有3(2+1)个麦子.。小码哥需要捡拾麦田里全部的麦子，你能帮小码哥算算米的麦田一共
能捡拾多少麦子吗？
格式
输入格式：一行一个整数n(1<n≤1000)表示麦田一共有n米。
输出格式：一行一个整数表示麦田里麦子总数。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,temp,ans;
cin >>n;
for (int i=1;i<=n;i++){
temp=(1+i)*i/2;
ans +=temp;
}
cout <<ans;
return 0;
}
小码哥玩游戏
难度：白银
①时间限制：1秒
巴占用内存：256M
小码哥和朋友在玩游戏，游戏内容为在给定的的m*n列的数组中(1≤m,n≤100)，该数组
中元素由[A,Z]和0组成，其中0表示该位置无字符，然后由玩家指定一个字符（字符范围为[A,
Z])，最后统计与该字符相邻的字符数量，最终数量最多的人胜出。现在请通过编程帮助小码哥计
算出给定一个字符后最终相邻的字符数。
请注意：
·最终的结果里，需要去重，比如，玩家指定的字符是A,A在[6,1]、[1,0]、[2,1]、[1,2]四
个位置都有，而[1,1]是字符B,则B和这四个位置的字符A都是相邻的，但是B在最终的结果里只需
要计数一次。
·相邻只有上下左右相邻；
·相邻的字符如果和指定字符一致，则不统计该相邻字符，即对于数组BAA,如果给定字符为A,
则相邻字符数为1，其中B计数，而右侧的A不计数。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 107;
int m,n;
char ch,c[N][N];
set<char>s;
int main(){
memset(c,'0',sizeof(c));
cin >>m >>n >>ch;
for (int i = 1;i<=m;i++)
for (int j=1;j <= n;j++)
cin >> c[i][j];
for (int i=1;i <= m;i++)
for (int j=1;j <= n;j++){
if (c[i][j]!=ch)
continue;
s.insert(c[i -1][j]);
s.insert(c[i + 1][j]);
s.insert(c[i][j - 1]);
s.insert(c[i][j + 1]);
}
if (s.count(ch)!=0)
s.erase(ch);
if (s.count('0')!=0)
s.erase('0');
cout <<s.size();
return 0;
}
手机测试
难度：白银
0时间限制：1秒
巴占用内存：256M
小码哥最近想测试下手机的性能，当前该手机有三种模式：省电模式、正常模式和性能模式。当使
用手机玩游戏的时候，手机会自动进入性能模式，性能模式每分钟消耗电量为，当退出游戏
后，手机会在经过t1分钟后进入正常模式，正常模式下每分钟消耗电量为。然后正常模式运行
2时间后，手机会在后台自动关闭游戏进程，从而进入到省电模式，省电模式下手机每分钟消耗
电量为k。如果小码哥在手机处于正常模式或省电模式的情况下可直接开启游戏从而使手机进入到
性能模式。假如小码哥将会在以下a个时间段[1，r],2,r2],·,[a,ra]玩游戏，请帮忙计
算下从1到r。这个时间段使用的总电量。
注意：每个时间段不重合，即Ta-1<la。
格式
输入格式：一行需要输入6个整数：a,m,n,k,t1,t2,(1≤a≤100,0≤m,n,k≤
100,1≤t1,t2≤100)；
以下α行包含小码哥玩游戏的时间段。其中每行存在包含两个整数（使用空格
分隔)1和r(0<1<?<5000),分别代表该时间段玩游戏的开始
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
int a,m,n,k,t1,t2,l,r,idle,result;
int main() {
cin >> a >> m >> n >> k >> t1 >> t2;
int tmp = -1;
while (a--) {
cin >> l >> r;
if (tmp != -1) {
idle = l - tmp;
if (idle < t1)
result += idle * m;
else if (idle < t1 + t2)
result += t1 * m + (idle - t1) * n;
else
result += t1 * m + t2 * n + (idle - t1 - t2) * k;
}
result += (r - l) * m;
tmp = r;
}
cout << result;
return 0;
}
自动浇花机
难度：黄金
时间限制：1秒
巴占用内存：256M
小码哥在花园里种植了一排花，一共种。为了浇花方便，他发明了一个自动的浇花器，一共有
两个喷头，左边喷头从左往右浇花，右边的喷头从右往左浇花。左边的喷头的浇花的速度是右侧的
两倍（同一个花，左边的喷头花费的时间是右边的一半)。
假设两个喷头同时开始浇花，左边的从左侧开始，右边的从右侧开始，浇完一朵马上浇下一朵。
特别提示：
(1)如果左边的喷头到达一朵花的时候，右边的喷头正好在喷，则左边的喷头不会去喷这朵花，
左边的喷头什么也不会干，因为这个时候已经没有剩余的花了。
(2)如果右边的喷头到达一朵花的时候，左边的喷头正好在喷，则右边的喷头不会去喷这朵花，
右边的喷头什么也不会干，因为这个时候已经没有剩余的花了。
(3)如果左边和右边的喷头同时到达同一朵花，则由左边的喷头喷这朵花，右边的喷头什么也不
会干，因为这个时候已经没有剩余的花了。
小码哥想知道左侧的喷头最终浇了多少多花。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
const int N= 1007;
int n,t[N];
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> t[i];
int start = 0, end = n - 1, result = 0;
int startSum = 0;
int endSum = 0;
while (start <= end) {
if (startSum <= 2 * endSum) {
startSum += t[start];
start++;
result++;
} else {
endSum += t[end];
end--;
}
}
cout << result;
return 0;
}
买月饼
号难度：白银
①时间限制：1秒
巴占用内存：256M
中秋节快到了，小码哥打算去商店买一些中秋月饼作为礼物送给亲戚朋友们，而每份月饼的价格为
m(1≤m≤1000)元。假设小码哥身上有非常多张面额为19元的纸币和只有一张面额为
(1≤n≤9)元的代金券，但现在商家没有零钱进行找零，最终小码哥决定多买几份使得刚好
能支付月饼价值。小码哥想知道自己最少要买多少份月饼才能使商家不需要进行找零。
格式
输入格式：一行两个整数m,n,其中m(1≤m≤1000)表示月饼的价格，n(1≤n≤
9)表示代金券的价值。
输出格式：最小需要购买的月饼数量，从而使商家不用进行找零。
未来战争
难度：黄金0时间限制：4秒
巴占用内存：256M
公元299年，小码哥和小码弟所在的两个国家陷入战争。小码哥所在的城市需要用激光武器来
防守，而激光武器需要定时充能。小码哥和他的战友们每天都要凌晨4点起床，然后去为守城的
激光武器充能。
我们可以把每个人为激光武器充能的时间段看作一段区间[1，]（以秒为单位，从凌晨4点开
始计时)，其中1表示充能的开始时刻，口表示充能的结束时刻。例如，如果一个人在3阳秒
的时候开始充能，直到1000秒的时候结束，我们可以表示为区间[36,1000]。
现在，我们有一个列表，其中包含了n个人为n个激光武器充能的时间段，我们想要计算以下
两个问题：
1.最长的至少有一个人在为激光武器充能的连续时间段是多长？
2.最长的没有人为激光武器充能的连续时间段是多长？
假设有3个人，他们的充能时间段分别为[300,1606]，[76,1260]和[150,218]。则
最长的至少有一个人在为激光武器充能的连续时间段为900秒（从300秒到1200秒)，最长
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
const int N =1e6+ 7;
int sub[N],a[N],n,l,r;
int lmin = 0x3f3f3f3f,rmax =-0x3f3f3f3f;
int ans1,ans2;//1系列变量表示至少有1个人，2系列表示没有人
int main(){
cin >>n;
while (n--) {
cin >> l >> r;
lmin = min(lmin, l), rmax = max(rmax, r);
sub[l]++, sub[r + 1]--;
}
for (int i=lmin;i <= rmax;i++)
a[i] = a[i-1]+sub[i];
int start1,end1,start2 = 0x3f3f3f3f,end2;
for (int i=lmin;i<=rmax+1 ;i++){
if(a[i]!=0 && a[i-1]==0){
end2 = start1 = i;
ans2 = max(ans2,end2 - start2);
}
if(a[i]== 0 && a[i-1] != 0){
end1 = start2 = i-1;
ans1 = max(ans1,end1 - start1);
}
}
cout <<ans1 <<" "<<ans2;
return 0;
}
双人成行
难度：白银
时间限制：1秒
巴占用内存：256M
小码哥和小码弟从小一起长大，他们习惯了彼此的存在，从4399到steam,他们配合的默契无
双。现在，他们一起来到了同一所大学的同一个专业，他们一起报名参加了ACM比赛。为了AC,
他们把所有的知识点都列了出来，分成了两部分，每个人各学一半。
到了比赛当天，一共出现了种类型的题目，小码哥和小码弟激动的翻阅了所有的题目，他们发
现，小码哥可以做出来其中的x种类型题目，而小码弟可以做出来其中的y种类型题目，现在，
请你帮忙计算，小码哥和小码弟是否可以AC所有的题目？
格式
输入格式：第一行包含一个整数n(1≤n≤10000)，表示比赛一共出现了n种类型的题
目，编号从1到n;
第二行首先包含一个整数x(0≤x≤)，紧跟着包含x个不同的整数
p1,p2,·,Px(1≤P≤m),这些整数表示小码哥可以通过的题目类型的索引：
最后一行首先包含一个整数y(0≤y≤几)，紧跟着包含y个不同的整数
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
int n,x,y,temp;
bool n2 [N];
int main() {
cin >> n;
cin >> x;
for (int i = 1; i <= x; i++) {
cin >> temp;
n2[temp] = true;
}
cin >> y;
for (int i = 1; i <= y; i++) {
cin >> temp;
n2[temp] = true;
}
cin >> x;
for (int i = 1; i <= n; i++) {
if (!n2[i]) {
cout << "Maybe Next Time.";
return 0;
}
}
cout << "It Takes Two.";
return 0;
}
魔法水晶球
难度：青铜
①时间限制：1秒
巴占用内存：256M
在一个远古的魔法世界里，有一种神奇的水晶球，它能够预测未来。但这个水晶球有一点特殊，它
每次只能预测一个数字是奇数还是偶数。
不过，水晶球近来的功能有所提升，它现在可以预测一个数字是不是质数(prime number)了。
如果是质数，用P'表示；如果是奇数，用0表示；如果是偶数，用‘’表示（一个是质数和奇
数，就直接输出P’。同理，一个是质数和偶数，也直接输出P’)。
现在给你一个整数num,请你帮助水晶球判断是奇数、偶数还是质数，并输出结果。
格式
输入格式：一个整数num(1≤num≤100000)
输出格式：一个字符，表示一个数的奇偶性或质数性。如果是质数，用P'表示；如果是
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int a) {
if (a < 2)
return 0;
for (int i = 2; i * i <= a; i++)
if (a % i == 0)
return 0;
return 1;
}
int main(){
int num;
cin >>num;
if (isPrime(num))
cout <<"P";
else if (num % 2)
cout <<"O";
else
cout <<"E";
return 0;}
自驾游
难度：钻石
时间限制：10秒
巴占用内存：256M
小码哥最近刚考完驾照，又恰逢暑假将到，便决定自驾游一番，一来可以欣赏大美新疆，二来还能
磨炼驾驶技术。
小码哥查阅各种旅游资料后，挑选了几个旅游胜地，以及几条风景不错的公路，并规划出总行程
工的路线。由于新疆太大了，小码哥必须要在沿途多次加油才能跑完全程，在他规划的这条路线
上共计N个加油站，可以直接加满。第2个加油站位于P,想要在这里加满需要花费
C块钱，一个位置上可能有多个加油站。
小码哥的车油量上限为Mαcm,初始的时候视为油量满额，每消耗一单位油，可以跑一单位行
程。当油量见底的时候，车就会抛锚（如果当前位置有加油站，他仍然可以加油）。小码哥预算可
拿出S块钱用于加油，他想知道自己能否完成这次自驾游。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
int n,L,maxn,S;
struct SHOP{
int Pi,Ci;
}a[2007];
struct NODE{
int distance,money,id;
};
bool cmp(SHOP x,SHOP y){
if (x.Pi < y.Pi)
return true;
return false;
}
int main(){
while (cin >>n >>L >>maxn >>S){
for (int i=1;i<=n;i++) {
cin >> a[i].Pi >> a[i].Ci;
if (a[i].Ci > S)
a[i].Pi = 20001;
}
sort(a +1,a +n +1,cmp);
queue<NODE>q;
q.push({0,S,0});
bool flag = false;
while (!q.empty()){
NODE now = q.front();
q.pop();
if (L - now.distance <= maxn){
flag = true;
break;
}
for (int i=now.id + 1;i <=n;i++){
if (a[i].Pi -now.distance > maxn)
break;
int temp = now.money - a[i].Ci;
if (temp >=0)
q.push({a[i].Pi,temp,i});
}
}
if (flag)
cout <<"Yes"<<endl;
else
cout<<"No"<<endl;
}
return 0;}
文章压缩
号难度：白银
0时间限制：1秒
巴占用内存：256M
小码哥发明了一种压缩文章的编码方式。
篇文章中有个单词组成（小写英文字母组成的单词），这些单词中可能有重复的，单词之
间用换行符分隔，单词的位置从1开始，每经过一个换行符，单词的位置加1。
小码哥采用的编码方式最终获得的结果应该是这样的：
(1)所有的单词按照出现的顺序排列，先出现的在前面。
(2)所有的单词后面都跟着一个英文的小括号，里面记录了这个单词每一次出现的位置，如果出
现在了多个位置，则位置之间用英文逗号隔开，先出现的位置排列在前。
(3)由单词和括号组成的小串，相互之间直接相连，无分隔符。
格式
输入格式：第1行是文章中单词的数量n,n大于等于1，小于等于1000；
接下来的行是组成该文章的单词，按照在文章中的顺序出现，每个单词的长度
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1007;
int n,cnt;
string tmp,word [N],ans [N];
int main(){
cin >>n;
for (int i=1;i <= n;i++) {
cin >> tmp;
bool flag = false;
for (int j = 0; j < cnt; j++)
if (tmp == word[j]) {
ans[j] = ans[j] + "," + to_string(i);
flag = true;
break;
}
if (!flag) {
word[cnt] = tmp;
ans[cnt] = to_string(i);
cnt++;
}
}
for (int i=0;i<cnt;i++)
cout <<word[i]<<"("<<ans[i]<<")";
return 0;
}
银河贸易市场
难度：钻石
时间限制：1秒
巴占用内存：256M
小码哥自小沉迷于策略游戏，如今更是痴迷于《Stel1aris》。游戏里有一个设定叫银河贸易市
场，拿下提名将大大提高贸易能力。
由于各势力均统领很多星系，势必存在贸易发展不均衡的情况，而银河贸易市场又只能设立在一个
星系里，因此需要选在最均衡的地方。若将势力的星系图抽象为α×b的点阵，则银河贸易市
场需要设立在×n区域内贸易最大值和最小值之差最小的星系。
由于银河贸易市场的提名活动只能申请一个星系，因此小码哥需要计算出自己势力范围内最平衡的
地方贸易差值是多少。
格式
输入格式：第一行输入三个整数a,b,n;
接下来α行，每行b个以空格隔开的非负整数c，表示各星系的贸易值。
//
// Created by abner on 2023/11/22.
//
#include <bits/stdc++.h>
#define N 1007
using namespace std;
/*num原始a*b矩阵，num1对行用单调队列，变成a*(b-n+1)矩阵；
为了方便函数调用，num1的转置矩阵为num2,为(b-n+1)*a矩阵；
然后对num2的行用单调队列，变成(b-n+1)*(a-n+1)矩阵num3
最后num3就是每个n*n矩阵的最大值和最小值，求答案即可
*/
int a,b,n,num[N][N],ans = 0x3f3f3f3f;
int num1MAX [N][N],num2MAX [N][N],num3MAX [N][N];
int num1MIN [N][N],num2MIN [N][N],num3MIN [N][N];
//单调递增，每次队头是最小值。长度为n的数组a,k为窗口大小
//结果存储在b中。b一共存储了n-k+1个数。
void getmin(int *a,int n,int k,int *b){
deque<int>q;
for (int i=1;i<=n;i++) {
if (!q.empty() && q.front() <= i - k)
q.pop_front();
while (!q.empty() && a[i] <= a[q.back()])
q.pop_back();
q.push_back(i);
if (i >= k)
b[i - k + 1] = a[q.front()];
}}
//单调递减，每次队头是最大值。长度为的数组a,k为窗口大小
//结果存储在b中。b一共存储了n-k+1个数。
void getmax(int *a,int n,int k,int *b) {
deque<int> q;
for (int i = 1; i <= n; i++) {
if (!q.empty() && q.front() <= i - k)
q.pop_front();
while (!q.empty() && a[i] >= a[q.back()])
q.pop_back();
q.push_back(i);
if (i >= k)
b[i - k + 1] = a[q.front()];
}
}
//m*n的矩阵a,转置为n*m的矩阵b
void trans(int a[N][N],int m,int n,int b[N][N]){
for (int i=1;i <= m;i++)
for (int j=1;j<=n;j++)
b[j][i]=a[i][j];
}
int main(){
cin >>a >>b >>n;
for (int i = 1;i <=a;i++)
for (int j=1;j <= b;j++)
cin >>num[i][j];
for (int i=1;i<=a;i++) {
getmax(num[i], b, n, num1MAX[i]);
getmin(num[i], b, n, num1MIN[i]);
}
trans(num1MAX,a,b -n +1,num2MAX);
trans(num1MIN,a,b -n +1,num2MIN);
for (int i=1;i<=b -n +1;i++){
getmax(num2MAX[i],a,n,num3MAX[i]);
getmin(num2MIN[i],a,n,num3MIN[i]);
}
for (int i= 1;i <= b-n + 1;i++)
for (int j=1;j<=a -n + 1;j++)
ans= min(ans,num3MAX[i][j]-num3MIN[i][j]);
cout <<ans;
return 0;}
