蓝桥杯 题库 简单 每日十题 day12

01 列名

问题描述
在Excel中，列的名称使用英文字母的组合。前26列用一个字母，依
次为A到Z，接下来26×26列使用两个字母的组合，依次为AA到zz.
请问第2022列的名称是什么？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为
一个由大写字母组成的字符串，在提交答案时只填写这个字符串，填写
多余的内容将无法得分。

#include 
using namespace std;
int main()
{

  char a[26]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
  int i,j,k;
  int count=0;
  for(i=0;i<26;i++)
  {
     for(j=0;j<26;j++)
     {
       for(k=0;k<26;k++)
       {
          count++;
          if(count==1320) 
           {
             cout<<a[i]<<a[j]<<a[k];
           }
       }
     }
  }
  return 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

比赛时可以用EXCEL 直接得到答案

#include 
using namespace std;
int main()
{
  cout << "BYT";
  return 0;
}
1
2
3
4
5
6
7

02 特殊日期

问题描述
对于一个日期，我们可以计算出年份的各个数位上的数字之和，也可以分别计算月和日的各位数字之和。请问从1900年1月1日至9999年12月31日，总共有多少天，年份的数位数字之和等于月的数位数字之和加日的数位数字之和。
例如，2022年11月13日满足要求，因为2+0+2+2=（1+1)+(1+3)。
请提交满足条件的日期的总数量。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include

int fun(int n){
  int sum=0;
  while(n){
    sum+=n%10;
    n/=10;
  }
  return sum;
}
int main(){
  int count=0;
  int i,j,year,month,days[13]={0,31,28,31,30,31,30,31,31,30,31,30,31};
  for(year=1900;year<=9999;year++){
    if(year%4==0&&year%100!=0||year%400==0)
        days[2]=29;
    else
        days[2]=28;
    for(i=1;i<=12;i++){
       for(j=1;j<=days[i];j++){
         if(fun(year)==fun(i)+fun(j))count++;
     }
    }
  }
  printf("%d",count);
  return 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

03 滑行

问题描述
小蓝准备在一个空旷的场地里面滑行，这个场地的高度不一，小蓝用
一个n行m列的矩阵来表示场地，矩阵中的数值表示场地的高度。
如果小蓝在某个位置，而他上、下、左、右中有一个位置的高度（严
格）低于当前的高度，小蓝就可以滑过去，滑动距离为1。
如果小蓝在某个位置，而他上、下、左、右中所有位置的高度都大于
等于当前的高度，小蓝的滑行就结束了。
小蓝不能滑出矩阵所表示的场地。
小蓝可以任意选择一个位置开始滑行，请问小蓝最多能滑行多远距离。
输入格式
输入第一行包含两个整数n，m，用一个空格分隔。接下来n行，每行包含m个整数，相邻整数之间用一个空格分隔，依次表示每个位置的高度。
输出格式
输出一行包含一个整数，表示答案。
样例输入

4 5
1 4 6 3 1 
11 8 7 3 1 
9 4 5 2 1 
1 3 2 2 1
1
2
3
4
5

样例输出

7
1

样例说明
滑行的位置一次为(2,1),(2,2),(2,3),(3,3),(3,2),(4,2),(4,3)
评测用例规模与约定
对于30%评测用例，1<=n<=20，1<=m<=20，0<=高度<=100。
对于所有评测用例，1<=n<=100，1<=m<=100，0<=高度<=10000。

#include 
#include 
#include  
using namespace std;
const int N=110;
int dx[]={1,-1,0,0},dy[]={0,0,1,-1};   //方向数组，记录四个方向的偏移量 
int g[N][N];
int f[N][N];
int n,m;  
//dfs(x,y)返回从(x,y)开始滑行，可以滑行的最大距离 
int dfs(int x,int y){
    if(f[x][y]!=-1) return f[x][y];     //如果该状态已经被计算过则直接返回 
    f[x][y]=1;        //当前状态最少是1（当前位置） 
    //枚举上下左右四个方向 
    for(int i=0;i<4;i++){
        int a=x+dx[i],b=y+dy[i];
        //如果该方向在范围内且可以滑过去 
        if(a>=1&&a<=n&&b>=1&&b<=m&&g[a][b]<g[x][y])
           f[x][y]=max(f[x][y],dfs(a,b)+1);   //转移方程 
    }
    return f[x][y];
} 
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            cin>>g[i][j];
        }
    }
    int ans=1;
    memset(f,-1,sizeof f);      //初始化每个状态都为-1，表示为都没有计算过 
    //枚举每个点，从每个点开始滑行，求出最大滑行距离，最后再取一个最大值，即为答案 
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            ans=max(ans,dfs(i,j)); 
        }
    }
    cout<<ans;
    return 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
35
36
37
38
39
40

04 星期几

问题描述
给定一天是一周中的哪天，请问n天后是一周中的哪天？
输入格式
输入第一行包含一个整数w，表示给定的天是一周中的哪天，
w为1到6分别表示周一到周六，w为7表示周日。
第二行包含一个整数n。
输出格式
输出一行包含一个整数，表示n天后是一周中的哪天，1到6分别表示周一到周六，
7表示周日。
样例输入

6
10
1
2

样例输出

2
1

#include 
#include 

int main(int argc, char *argv[])
{
    int week[]={7,1,2,3,4,5,6};
    int w,n,d;
    scanf("%d",&w);
    scanf("%d",&n);
    n=n%7;
    w=(w+n)%7;
    d=week[w];
    printf("%d",d);
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

05 判断蓝桥

问题描述
输入一个字符串，请判断这个字符串是否正好是lanqiao。
在输入时如果只是大小写不同也算作相同。
输入格式
输入一行包含一个字符串。
输出格式
如果是1anqiao，输出全小写的字符串yes，否则输出全小写的字符串no。
样例输入

LanQiao
1

样例输出

yes
1

样例输入

QiaoLan
1

样例输出
no
评测用例规模与约定
对于所有评测用例，输入的字符串由大写或小写英文字母组成，长度
至少为1个字符，不超过20个字符。

#include 
#include 
using namespace std;
int main()
{
  string str;
  cin>>str;
  if((str[0]=='l'||str[0]=='L')&&(str[1]=='a'||str[1]=='A')&&(str[2]=='n'||str[2]=='N')&&(str[3]=='q'||str[3]=='Q')&&(str[4]=='i'||str[4]=='I')&&(str[5]=='a'||str[5]=='A')&&(str[6]=='o'||str[6]=='O')&&str.size()==7)//判断每个字符组的字母，再加上字符串大小为7，输出yes，否则输出no；
  cout<<"yes";
  else cout<<"no";
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

06 信号覆盖

问题描述
小蓝负责一块区域的信号塔安装，整块区域是一个长方形区域，建立
坐标轴后，西南角坐标为（0,0），东南角坐标为（W，0)，西北角坐
标为（0,H），东北角坐标为（W,H）。其中W,H都是整数。
他在n个位置设置了信号塔，每个信号塔可以覆盖以自己为圆心，
半径为R的圆形（包括边缘）。
为了对信号覆盖的情况进行检查，小蓝打算在区域内的所有横纵坐标
为整数的点进行测试，检查信号状态。其中横坐标范围为0到W，
纵坐标范围为0到H，总共测试（W+1）x（H+1)个点。
给定信号塔的位置，请问这（W+1) x (H+1)个点中有多少个点
被信号覆盖。
输入格式
输入第一行包含四个整数W，H，n，R，相邻整数之间使用一个空格分隔。
接下来n行，每行包含两个整数x，y，表示一个信号塔的坐标。
信号塔可能重合，表示两个信号发射器装在了同一个位置。
输出格式
输出一行包含一个整数，表示答案。
样例输入

10 10 2 5
0 0
7 0
1
2
3

样例输出

57
1

评测用例规模与约定
对于所有评测用例，1≤W,H≤100，1≤n≤100,1≤R≤
100,0≤x≤W,0≤y≤H。

#include
using namespace std;
struct yx{
    int x,y;
    }t[101];
int main()
{
    int w,h,n,r,ans=0;
    cin>>w>>h>>n>>r;
    for(int i=0;i<n;++i)
    cin>>t[i].x>>t[i].y;
    for(int i=0;i<w+1;++i)
    for(int j=0;j<h+1;++j)
    for(int k=0;k<n;++k)
    {
    if((t[k].x-i)*(t[k].x-i)+(t[k].y-j)*(t[k].y-j)<=r*r)
    {
        ++ans;
        break;
    }
    }
    cout<<ans;
return 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

07 幸运数字

#include 
using namespace std;
int sumOfDigits(int integer, int base);
int main()
{
    int integer=0;  //待测试的整数
    for(int amount=0; amount<2023; ) //数量
    {
      integer++;
      if(integer%sumOfDigits(integer, 2)==0&&
         integer%sumOfDigits(integer, 8)==0&&
         integer%sumOfDigits(integer, 10)==0&&
         integer%sumOfDigits(integer, 16)==0
        )
        amount++;
    }
    cout<<integer;
    return 0;
}
int sumOfDigits(int integer, int base)
{   //计算十进制整数integer在base进制下的数位之和
    int sum=0;
    while(integer>0)
    {
        sum+=integer%base;
        integer/=base;
    }
    return sum;
}
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

08 求和

#include
using namespace std;
int main(){
    long long ans=0,a=1,b=20230408;
    ans=((a+b)*b)/2;
    cout<<ans;
    return 0;
}
1
2
3
4
5
6
7
8

09 平均

10
1 1
1 2
1 3
2 4
2 5
2 6
3 7
3 8
3 9
4 10
1
2
3
4
5
6
7
8
9
10
11

样例输出

27
1

#include 
using namespace std;
#define int long long
vector<int> a;
vector<int> b[10];
bool cmp(int x,int y){
  return x>y;
}
void solve(){
  int n;
  cin>>n;
  int ans=0;
  //每种数字保留n/10个 代价和是这种数字的总和减去最大的n/10个代价的差
  map<int,int> mp;//计算这种数代价和
  map<int,int> mpfornum;//这个数字的目前数目
  map<int,int> mpmax;//最大的n/10个数的代价和
  int temp=n/10;//目标个数
  while(n--){
    int l,r;
    cin>>l>>r;
    a.push_back(l);
    b[l].push_back(r);
    mp[l]+=l;//计算这种数字的代价总和
    mpfornum[l]++;
  }

  for(int i=0;i<=9;i++){
    sort(b[i].begin(),b[i].end());
  }

  for(int i=0;i<=9;i++){
    if(mpfornum[i]>temp){
        //有mpfornum[i]-temp个数需要转换
        int changes=mpfornum[i]-temp;
        for(int j=0;j<changes;j++){
            //cout<
            ans+=b[i][j];
        }
        //cout<
    }
  }
  cout<<ans;
}
signed main()
{
  // 请在此输入您的代码
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  int t=1;
  //cin>>t;
  while(t--){
    solve();
    cout<<endl;
  }
  return 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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

10 最大连通

问题描述
小蓝有一个30行60列的数字矩阵，矩阵中的每个数都是0或1。

110010000011111110101001001001101010111011011011101001111110

010000000001010001101100000010010110001111100010101100011110 

001011101000100011111111111010000010010101010111001000010100 

101100001101011101101011011001000110111111010000000110110000 

010101100100010000111000100111100110001110111101010011001011 

010011011010011110111101111001001001010111110001101000100011 

101001011000110100001101011000000110110110100100110111101011 

101111000000101000111001100010110000100110001001000101011001 

001110111010001011110000001111100001010101001110011010101110 

001010101000110001011111001010111111100110000011011111101010 

011111100011001110100101001011110011000101011000100111001011 

011010001101011110011011111010111110010100101000110111010110 

001110000111100100101110001011101010001100010111110111011011 

111100001000001100010110101100111001001111100100110000001101 

001110010000000111011110000011000010101000111000000110101101 

100100011101011111001101001010011111110010111101000010000111 

110010100110101100001101111101010011000110101100000110001010 

110101101100001110000100010001001010100010110100100001000011 

100100000100001101010101001101000101101000000101111110001010 

101101011010101000111110110000110100000010011111111100110010 

101111000100000100011000010001011111001010010001010110001010 

001010001110101010000100010011101001010101101101010111100101 

001111110000101100010111111100000100101010000001011101100001 

101011110010000010010110000100001010011111100011011000110010 

011110010100011101100101111101000001011100001011010001110011 

000101000101000010010010110111000010101111001101100110011100 

100011100110011111000110011001111100001110110111001001000111 

111011000110001000110111011001011110010010010110101000011111 

011110011110110110011011001011010000100100101010110000010011 

010011110011100101010101111010001001001111101111101110011101
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

如果从一个标为1的位置可以通过上下左右走到另一个标为1的位
置，则称两个位置连通。与某一个标为1的位置连通的所有位置（包
括自己）组成一个连通分块。请问矩阵中最大的连通分块有多大？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果
为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

#include 
using namespace std;
char a[35][65];//千万注意，这题是字符型，我一开始用整形，全是0
int b[35][65]={0};
int num=0;
int xy[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
void dfs(int x,int y)
{
  if(x<1||x>30||y<1||y>60||a[x][y]=='0'||b[x][y]==1)//不符合标准的就返回
    return ;
  b[x][y]=1;//判定用的，看这个位置是否被搜索过，搜过就置1
  num++;//深度搜索周边所有为1的位置时+1，记录本次搜索的连通量
  for(int i=0;i<4;i++)
  {
    int tx=x+xy[i][0];//进行偏移量转化
    int ty=y+xy[i][1];
    if(tx>=1&&tx<=30&ty>=1&&ty<=60&&a[tx][ty]=='1'&&b[tx][ty]==0)//偏移量满足条件的
      dfs(tx,ty);                                                                                                  //继续搜索；
  }
}

int main()
{
  int res=0;
  for(int i=1;i<=30;i++)
  {
    for(int j=1;j<=60;j++)
    {
      cin>>a[i][j];
    }
  }
   for(int i=1;i<=30;i++)
  {
    for(int j=1;j<=60;j++)
    {
      num=0;      //连通量初始化
      dfs(i,j);        //对这个位置进行搜索
      res=max(num,res);//记录最大值
    }
  }
 // cout<
    cout<<148;
  // 请在此输入您的代码
  return 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
35
36
37
38
39
40
41
42
43
44
45