目录
圣诞树上的星星
难度:青铜
时间限制: 1秒占用内存:64M
小码哥在过圣诞节!
小码哥家里有很多个星星 *，他打算把这些星星装饰到圣诞树上(圣诞树最少1层，最多109层)，每一层都放上与层数一致的星星数量，但是当层数为3的倍数的时候，该层圣诞树上不装饰星星，用树根“”代替。如二层的圣诞树，第一层有1颗星星，第二层有2颗星星:三层的圣诞树第一层有1颗星星，第二层有2颗星星，第三层不装饰星星，有0颗星星。
现在有一颗 n层的圣诞树，你能帮他装饰树上的星星吗?
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
for (int i=1;i<=n;i++){
if(i%3==0)
cout <<"|"<<endl;
else{
for(int j=1;j<=i;j++)
cout<<"*";
cout <<endl;
}
}
return 0;
}
军团大战
难度:白银时间限制:秒占用内存: 64 M
在字母世界中，每个大写的字母都是一个军团，不同字母军团集合AAAABBCCCCCDDDDDDDDDDDDDDDD表示A军团有4个单位，B军团有2个单位，C有5个单位，D军团有16个单位，D军团人数最多。小码哥是一个新人军师，他想成为字母军团的军师，但是他想成为数量最多的军团的军师(若军团数量最多的军团有多个时，选择字母表顺序靠前的字母军团》，你能建议他去哪个军团吗?
格式
输入格式:一行一个长度为 n(1n100000)字符串，表示不同军团的集合，不一定有全部A-Z字母。
输出格式:行一个字符，表示最多单位的军团
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
string s;
int a[26];
int main(){
cin >>s;
for (int i=0;i<s.length();i++)
a[s[i] - 'A']++;
int num = 0,ans;
for (int i=0;i<26;i++)
if (a[i]>num){
num = a[i];
ans = i;
}
cout <<char('A'+ ans);
return 0;
}
堆煤球
难度：青铜
0时间限制：1秒
巴占用内存：64M
小码哥是一位煤矿工人，他每天的工作就是要挖煤矿煤球，第1天挖1个煤球，第2天挖2+1个煤
球，…n(1≤n≤1000)天挖n十(n-1)+(n-2)+..+1个煤球。小码哥的老板是
个黑心老板，他让小码哥上7天班，第8天才休息1天，并且他会时不时的抽查小码哥在1，(1≤
i≤)≤m,1≤n≤1000)天内挖的的煤球总数数量。小码哥会挖煤球，但是不太会算术，你
能帮小码哥计算范围内挖的煤球总数吗？
格式
输入格式：一行两个整数i)，以空格分开。
其中：1≤i≤j≤n,1≤m≤1000，表示抽查天数范围。
输出格式：一行一个整数表示范围内煤球总数。
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int main(){
int i,j,ans =0;
cin >>i>>j;
for(int k = i;k <= j;k++)
if (k % 8)
ans+=(1+k)*k/2;
cout <<ans;
return 0;
}
武力对决
难度:青铜时间限制: 1秒四占用内存:64 M
江湖中正在举行武林大会，参加武林大会比试的胜者可以获得经验值，获得的经验值为自身武力值与对方武力值的差值。小码哥是一位武林高手，只要他在场，他的武力值一定就是最高的(最高的可有多个)。小码哥有个癖好，就是在进行武林比试时一定要选择在场人中武力值最低的人(最低可有多个)，这样他才能获得最大的经验值。现在有包括小码哥在内的 N(1< N100000)个人在参加武林大会，将 N 个人的武力值进行统计得到武力值数组 n,n2,n3,...nn，你能帮小码哥计算他能得到最大多少的经验值吗?
格式
输入格式:第一行一个整数 N(1<N100000) 表示参加武林大会的人数第二行一个长度为(1N<100000) 整数数组表示参与的武林大会人的武力值集合，其中个人武力值 (数组元素) n(1n1000) 并且可以重复
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int N,n,maxn = -0x3f3f3f3f,minn = 0x3f3f3f3f;
int main(){
cin >>N;
int temp;
while (N--){
cin >> temp;
maxn =max(maxn,temp);
minn = min(minn,temp);
}
cout << maxn -minn;
return 0;
}
小码哥教数学
时间限制: 1秒难度:黄金占用内存:256M
为了加深学生对数学中两个数互质的理解，小码哥带大家玩游戏小码哥从学生中随机抽出偶数个的学生，最少2个，最多16个，然后把抽出来的学生分为两组并各自站成一排，每一组的每一位学生，小码哥都随机从1到9里面抽一个数字发给他(两个学生数字可以相同)。这样每一组学生用他们领到的数字可以组成一个数，比如某一组有两个学生，第一个学生拿到的是1，第二个学生拿到的是2，则组成的数字是12。现在，如果这两组学生组成的两个数字互质，则直接输出0且结束游戏。否则，让两组的所有学生左移1位(第一个学生移动到最右边)，比如某一组的数字是123，则左移1位变成了231，如果石质，输出1且结束游戏。依次类推，直到两个数字互质为止。然后输出到互质状态下移动的次数如果不管怎么移动，两组数字都不能互质，则输出-1。
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
string a,b;
int gcd(int a,int b){return b ==0 ? a : gcd(b,a % b);}
int StoI(string s){
int len =s.length(),temp = 0;
for (int i=0;i<len;i++)
temp = temp * 10 + s[i]-'0';
return temp;
}
int main() {
cin >> a >> b;
int len = a.length();
if (gcd(StoI(a), StoI(b)) == 1) {
cout << 0;
return 0;
}
for (int i = 1; i < len; i++) {
a = a.substr(1) + a[0];
b = b.substr(1) + b[0];
if (gcd(StoI(a), StoI(b)) == 1) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
小码哥玩字母独
难度:白银 时间限制: 1秒四占用内存:256M
受到数独游戏启发，小码哥决定开发一款字母独的游戏，游戏规则如下:在一个nxn的格子里，每一个格子填写小写英文字母，如果主对角线(左上到右下)的字母互相之间都不同，则游戏通关。
格式
输入的第一行一个整数n，n大于等于1，且小于等于100;输入格式:接下来的n行，每一行有n列，都是小写字母
输出格式:如果通关则输出accept，否则输出refuse。
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 107;
int n;
char a[N][N];
bool b[26];
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
cin >> a[i][j];
for (int i = 1; i <= n; i++) {
int num = a[i][i] - 'a';
if (b[num]) {
cout << "refuse";
return 0;
} else
b[num] = true;
}
cout << "accept";
return 0;
}
跳跳棋
难度:白银时间限制: 3秒四占用内存:256M
小码哥发明了一个跳跳棋。
在一个N行乘以M列的格子里，每一个格子里都有一个数字T。棋子从左上角的格子出发，如果它当前所在的格子的数字T不是质数，则棋子移动到右侧紧邻的格子(即行的索引不变，列的索引加上1)。当右侧没有格子时，棋子移动到下一行的最左侧的格火
否则，如果是质数，则棋子向右跳跃S格(棋子的列索引加上S)。S的值，是T除以19之后的余数。如果棋子跳到了本行最右侧的格子外面了，则棋子也是移动到下一行的最左侧的格子。
棋子达到最右下角的格子，或者棋子在最后一行，跳到了本行最右侧的格子外面了，游戏结束。你需要求出棋子总共遇到的质数的次数(棋子放在了质数的格子里，我们认为是一次“遇到”，那种跳着从头上过去的不算)。
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int n,m,a[107][107],ans;
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() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m;) {
if (isPrime(a[i][j])) {
ans++;
j = j + a[i][j] % 10;
} else
j = j + 1;
if (j > m - 1)
break;
}
cout << ans;
return 0;
}
激光扫描游戏
难度:白银
时间限制:6秒四占用内存:512M
小码哥在玩激光扫描游戏。
激光扫描游戏在一个1880乘以1000的格子里进行，开始的时候。激光笔照射在第0行的第@列(包含)到第499列(包含)，扫描到的格子的数量是499-0+1=500。即，每一次扫描范围，包括左侧和右侧索引本身。
激光笔扫描完一行之后，会去扫描下一行，直到扫描完所有的行。每一行的所有格子都有可能被埋着地雷，如果地雷恰好在当前行的扫描的区间内，则它会爆炸，它的爆炸会影响到激光笔的右侧扫描范围(左侧一直保持8不变)，这样到下一行时，激光笔的扫描范围就会改变(当前的行时还不会变)。
如何影响呢?右侧的扫描位置的索引，会被加上地雷的行号与列号的差(行减去列，显然如果是正的，则增加，否则会减小)，如果一行有多个地雷，则所有的地雷会累积效果，并一起作用到激光笔上。
注意:激光笔的右侧扫描位置最大为999，最小为0。且这个激光笔的扫描范围的变化是持久性的，不会因为当前的行没有地雷而又恢复到499。
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m[1000][2];
cin >> n;
for (int i = 0; i < n; i++)
cin >> m[i][0] >> m[i][1];
int start = 0, end = 499, ans = 0;
for (int i = 0; i <= 999; i++) {
ans += end - start + 1;
int adjust = 0;
for (int j = 0; j < n; j++)
if (m[j][0] == i && end >= m[j][1])
adjust += m[j][0] - m[j][1];
end += adjust;
if (end < 0)
end = 0;
if (end > 999)
end = 999;
}
cout << ans;
return 0;
}
数数游戏
难度:白银时间限制: 1秒占用内存:256M
小码哥是一个热爱数学的小学生，他喜欢玩一个有趣的游戏，规则如下: 给定一个正整数n，小码哥从1开始数到n，但是有一些特殊规则:如果当前数字能被3整除或包含数字3，他要喊出“Fizz”;如果当前数字能被5整除或包含数字5，他要喊出“Buzz”如果同时满足规则1和规则2，他要喊出“FizzBuzz”;请帮助小码哥写一个计算，根据输入的正整数n，输出小码哥分别喊Fzz、Buzz、FizzBuzz的次数。
格式
输入格式:一行包含两个整数 n(n100000)表示小码哥要喊的数
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int n,fizzCount,buzzCount,fizzBuzzCount;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
if ((i % 3 == 0 || to_string(i).find('3') != string::npos) &&
(i % 5 == 0 || to_string(i).find('5') != string::npos))
fizzBuzzCount++;
else if (i % 3 == 0 || to_string(i).find('3') != string::npos)
fizzCount++;
else if (i % 5 == 0 || to_string(i).find('5') != string::npos)
buzzCount++;
}
cout << fizzCount << endl;
cout << buzzCount << endl;
cout << fizzBuzzCount;
return 0;
}
小狗巴克
难度:青铜时间限制:1秒占用内存: 256 M
小狗巴克是一只聪明的小狗，它喜欢与主人一起玩各种游戏。最近，巴克的主人小码哥发明了一个新游戏。
在这个游戏中，小码哥会给出一个字符串A，然后巴克需要找出一个特定的字符串B是否在A中。
然而，这个游戏对小狗来说有点难，因为字符串A中的字母都是大写的，但它们被其他字符“!”分隔。例如，一个A可能是“C!A!T!S!A!R!E!A!W!E!S!O!M!E!”，而要查找的字符串B可能是“AWESOME”，若字符串B AWESOME 在A中存在，则输出 True，反之则输出False。你需要编写一个程序，来帮助巴克解决这个有趣的巴克与单词游戏
格式
输入格式:第一行一个长度为 S(1S1000000) 的字符串A;第二行一个长度为 s(1< s S)的全大写字母表示特定的字串B
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
string A,B,C;
int main() {
cin >> A >> B;
for (int i = 0; i < A.length(); i++)
if (A[i] != '!')
C += A[i];
if (C.find(B) == string::npos)
cout << "False";
else
cout << "True";
return 0;
}
魔塔密码
难度:青铜时间限制: 1秒四占用内存:64M
勇敢的冒险者小码哥在探索一座古老的魔塔时发现了一扇需要密码才能打开的门。密码是通过解读串神秘的字符序列获得的，而这串字符序列是由塔的守护者随机散布在一段文字中。幸运的是，小码哥找到了一本日记，里面记录了解读密码的关键一“密码是由字符序列中，取第一个字符后每隔k-1个字符(取第k个字符) 取一个组成的”。
当k=1时，密码等于原字符序列。
你的任务是编写一个程序，帮助小码哥找出隐藏在一段文字中的密码
格式
输入格式:第一行包含一个整数 n(1 nS)，表示间隔的字符数;第二行包含一个由小写字母组成的字符串 S(1 S100000) ，代表塔的守护者留下的字符序列
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main(){
cin >>n >>s;
for (int i=0;i<s.length();i++)
{if(i%n==0)
cout <<s[i];
}
return 0;
}
地狱尖兵
黄金难度:
时间限制:8秒四占用内存:256M
在小码哥完成炮火支援后，前线的作战压力得以有效降低，作为队长的小码妹决定继续完成战术目标。不幸的是，虽然敌人失去了部分迫击炮的支援，但是地面部队的压力仍旧很大，建筑错综复杂，敌人也十分隐蔽。综合考虑现状后，小码妹决定暂时撤退，先与另一支小队会和，再总攻制高点。
现在小码妹拿到了这片区域的地图，其中表示道路，表示建筑，P表示当前位#表示制高点。每个位置可以向上下左右四个方向移动，置，表示另一支小队的位置，EK小码妹需要用最短的时间与其他小队会和，前往制高点(若没有会和，则不能进入制高点所在的位
格式
输入格式:第一行一个整数 T，代表数据的组数
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
const int N =507;
struct NODE {
int x, y;
int step;
bool flag;
}currN,nxtN;
int T,n,m,x,y;
char mp [N][N];
bool vis [N][N][2];
int dx[6]={1,-1,0,0};
int dy[6]={0,0,1,-1};
bool check(NODE node){
int x = node.x,y = node.y;
bool flag = node.flag;
if (x <1 || y <1 || x>n || y >m)
return false;
if (vis[x][y][flag]|| mp[x][y]=='#')
return false;
if (mp[x][y]=='E' && flag ==false)
return false;
return true;
}
int bfs(int x,int y) {
memset(vis, false, sizeof(vis));
queue<NODE> q;
q.push({x, y, 0, false});
vis[x][y][0] = true;
while (!q.empty()) {
currN = q.front();
q.pop();
if (mp[currN.x][currN.y] == 'E' && currN.flag)
return currN.step;
for (int i = 0; i < 4; i++) {
nxtN.x = currN.x + dx[i];
nxtN.y = currN.y + dy[i];
nxtN.flag = currN.flag;
nxtN.step = currN.step + 1;
if (mp[nxtN.x][nxtN.y] == 'K')
nxtN.flag = true;
if (check(nxtN)) {
q.push(nxtN);
vis[nxtN.x][nxtN.y][nxtN.flag] = true;
}
}
}
return -1;
}
int main() {
cin >> T;
while (T--) {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> mp[i][j];
if (mp[i][j] == 'P')
x = i, y = j;
}
if (bfs(x, y) < 0)
cout << "No solution" << endl;
else
cout << bfs(x, y) << endl;
}
return 0;
}
3D眩晕
难度:钻石时间限制: 3秒四占用内存:256M
小码哥是一名生物学家，闲时喜欢与同事打游戏，但他的一部分同事 3D 眩晕，所以很多游戏玩不了，于是小码哥决定利用自己的生物学知识探究 3D 眩晕的原因。
天道酬勤，在夜以继日的研究下，小码哥终于发现了决定人是否 3D 眩晕的基因序列 S，有这个碱基序列的人就会表现出 3D 眩晕的性状，但是他还发现对基因序列 S，任意修改其中不超过3个碱基，依然能够表现出晕 3D 的性状。
现在有一个表现出 3D 眩晕性状的人，他的基因序列是 S，小码哥需要你帮忙统计里面有多少个连续碱基序列可能是该基因 S，或者修改小于等于三个碱基能够变成 S
格式
输入格式:第一行输入一个正整数T，表示有几组数据每组数据第一行输入表现出3D 眩是性状的人的基因序列 S，第二行输入决定
//
// Created by abner on 2023/12/7.
//
#include <bits/stdc++.h>
using namespace std;
#define ULL unsigned long long
const int P = 131;
const int N = 1e5 + 7;
ULL p[N],h_s0 [N],h_s[N];
int T,len_s0,len_s,ans;
char s0[N],s[N];
void init(int len1,int len2) {
memset(h_s0, 0, sizeof(h_s0));
memset(h_s, 0, sizeof(h_s));
for (int i = 1; i <= len1; i++)
h_s0[i] = h_s0[i - 1] * P + s0[i];
for (int i = 1; i <= len2; i++)
h_s[i] = h_s[i - 1] * P + s[i];
}
ULL call(int l,int r){return h_s0[r]- h_s0[l - 1]*p[r -l + 1];}
ULL cal2(int l,int r){return h_s[r] - h_s[l - 1] * p[r -l + 1];}
int find(int x,int y){
int l=1,r = len_s - y +1,mid,ans = 0;
while (l<=r){
mid=(l+r)>>1;
if (call(x,x + mid -1)== cal2(y,y + mid -1))
l = mid +1,ans = mid;
else
r = mid - 1;
}
return ans;
}
bool check(int x) {
int p1 = x, p2 = 1;
for (int i = 1; i <= 3; i++) {
int len = find(p1, p2);
p1 += len + 1, p2 += len + 1;
if (p2 > len_s)
return true;
}
return call(p1, x + len_s - 1) == cal2(p2, len_s);
}
int main(){
cin >>T;
p[0]=1;
for(int i=1;i<=100000;i++)
p[i]=p[i-1]*P;
while (T--){
cin >> s0+1>> s+1;
len_s0 = strlen(s0 + 1),len_s = strlen(s + 1);
if (len_s0 < len_s){
cout << "0";
continue;
}
ans =0;
init(len_s0,len_s);
for (int i=1;i <= len_s0 - len_s + 1;i++)
if (check(i))
ans++;
cout <<ans <<endl;
}
return 0;
}
1524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
