蓝桥杯刷题篇①

Dear 丶 2023-10-12 17:51 42阅读 0赞

> 前言：hello各位童学们好呀！许久不见！本文为本人的蓝桥杯OJ的刷题笔记！文章隶属于专栏蓝桥杯，该专栏的目的是为了记录自己的刷题记录和学习过程，激励自己不断前行，为明年的ACM、ICPC、蓝桥杯等比赛做足准备，也希望可以帮助到一些同样在刷题道路上的小伙伴们！！！！

![在这里插入图片描述][da8f1c713e47435b9efdf4ca12b026fc.png]

### 题目汇总 ###

*  1、单词分析
 *  2、成绩统计
 *  3、最短路
 *  4、门牌制作
 *  5、卡片
 *  6、数字三角形
 *  7、成绩分析
 *  8、购物单
 *  9、空间
 *  10、排序
 *  11、跑步锻炼
 *  12、蛇形填数
 *  13、递增序列
 *  14、货物摆放
 *  15、九进制转十进制
 *  16、等差素数列
 *  17、七段码
 *  18、跳跃
 *  19、时间显示

# 1、单词分析 #

**题目描述**  
小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组 成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。

现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这 个字母出现的次数。

**输入描述**  
输入一行包含一个单词，单词只由小写英文字母组成。

对于所有的评测用例，输入的单词长度不超过 1000。

**输出描述**  
输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪 个。如果有多个字母出现的次数相等，输出字典序最小的那个。

第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。

**输入输出样例**  
**示例 1**  
输入

lanqiao  
copy  
输出

a  
2  
copy  
**示例 2**  
输入

longlonglongistoolong  
copy  
输出

o  
6

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        string s;
        int max=0,a[26]={
        0};
        char c;
        cin>>s;
        for(int i=0;i<s.length();i++)
        {
        
            a[s[i]-'a']++;
        }
        for(int i=0;i<26;i++)
        {
        
            if(a[i]>max)
            {
        
                max=a[i];
                c=i+'a';
            }
        }
        cout<<c<<endl;
        cout<<max<<endl;
        return 0;
    }

# 2、成绩统计 #

**题目描述**  
小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。

如果得分至少是 60 分，则称为及格。如果得分至少为 85 分，则称为优秀。

请计算及格率和优秀率，用百分数表示，百分号前的部分四舍五入保留整 数。

**输入描述**  
输入的第一行包含一个整数

n (1≤n≤10 4 )，表示考试人数。

接下来

n 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。

**输出描述**  
输出两行，每行一个百分数，分别表示及格率和优秀率。百分号前的部分 四舍五入保留整数。

**输入输出样例**  
**示例**  
输入

7  
80  
92  
56  
74  
88  
100  
0  
copy  
输出

71%  
43%

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int n;
        int grade;
        int sum1=0,sum2=0;
        cin>>n;
        for(int i=0;i<n;i++)
        {
        
            cin>>grade;
            if(grade>=60)
            {
        
                sum1+=1;
            }
            if(grade>=85)
            {
        
                sum2+=1;
            }
        }
        sum1=sum1*100.0/n*1.0+0.5;
        sum2=sum2*100.0/n*1.0+0.5;
        printf("%d%%\n%d%%",sum1,sum2);
    }

# 3、最短路 #

**题目描述**  
**本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。**

如下图所示，  
G 是一个无向图，其中蓝色边的长度是 1橘色边的长度是 2绿色边的长度是3.

![图片描述][bb9ba0adff3d4fb2aa50dab49091e637.png]

则从 A 到 S 的最短距离是多少？

> AC代码：

#include <iostream>
    using namespace std;
    int main()
    {
        
      printf("6");
      return 0;
    }

# 4、门牌制作 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝要为一条街的住户制作门牌号。

这条街一共有  
2020  
2020 位住户，门牌号从 1 到 2020 编号。

小蓝制作门牌的方法是先制作

0 到

9 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符

1、0、1、7，即需要

1 个字符 0，2 个字符 1，1 个字符 7。

请问要制作所有的 1 到 2020 号门牌，总共需要多少个字符 2？

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int count=0;
        int t;
        for(int i=1;i<=2020;i++)
        {
        
            t=i;
            while(t)
            {
        
                if(t%10==2)
                {
        
                    count++;
                    
                }
                t/=10;
            }
        }
        cout<<count;
    }

# 5、卡片 #

**题目描述**  
**本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。**

小蓝有很多数字卡片，每张卡片上都是数字 0 到 9。

小蓝准备用这些卡片来拼一些数，他想从

1 开始拼出正整数，每拼一个，就保存起来，卡片就不能用来拼其它数了。

小蓝想知道自己能从 1 拼到多少。

例如，当小蓝有 30 张卡片，其中 0 到 9 各 3 张，则小蓝可以拼出 1 到 10，

但是拼  
11  
11 时卡片  
1  
1 已经只有一张了，不够拼出  
11  
11。

现在小蓝手里有  
0  
0 到  
9  
9 的卡片各  
2021  
2021 张，共  
20210  
20210 张，请问小蓝可以从  
1  
1 拼到多少？

提示：建议使用计算机编程解决问题。

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int num[10];
        for(int i=0;i<10;i++)
        {
        
            num[i]=2021;
        }
        for(int i=1;;i++)
        {
        
            int x=i;
            while(x)
            {
        
                if(num[x%10]==0)
                {
        
                    cout<<i-1;
                    return 0;
                }
                num[x%10]--;
                x/=10;    
            }
        }
        return 0;
    }

# 6、数字三角形 #

**题目描述**  
![在这里插入图片描述][755f3dfa8e2d4ca0813ad772475dc644.png]  
上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。

路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右 边的那个数。此外，向左下走的次数与向右下走的次数相差不能超过 1。

**输入描述**  
输入的第一行包含一个整数

N (1≤N≤100)，表示三角形的行数。

下面的 N 行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数。

**输出描述**  
输出一个整数，表示答案。

**输入输出样例**  
**示例**  
输入

5  
7  
3 8  
8 1 0  
2 7 4 4  
4 5 2 6 5  
copy  
输出

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int e[101][101];
        int n;
        cin>>n;
        for(int i=1;i<=n;i++)
        {
        
            for(int j=1;j<=i;j++)
            {
        
                cin>>e[i][j];
            }
        }
        for(int i=2;i<=n;i++)
        {
        
            for(int j=1;j<=i;j++)
            {
        
                e[i][j]+=max(e[i-1][j],e[i-1][j-1]);
            }
        }
        if(n%2 == 0)
        {
        
            cout << max(e[n][n/2],e[n][n/2+1]);
        }
        else
        {
        
            cout << e[n][n/2+1];
        }
    }

# 7、成绩分析 #

**题目描述**  
小蓝给学生们组织了一场考试，卷面总分为 100 分，每个学生的得分都是一个 0 到 100 的整数。

请计算这次考试的最高分、最低分和平均分。

**输入描述**  
输入的第一行包含一个整数

n (1≤n≤10 4 )，表示考试人数。

接下来

n 行，每行包含一个 0 至 100 的整数，表示一个学生的得分。

**输出描述**  
输出三行。

第一行包含一个整数，表示最高分。

第二行包含一个整数，表示最低分。

第三行包含一个实数，四舍五入保留正好两位小数，表示平均分。

**输入输出样例**  
**示例**  
输入

7  
80  
92  
56  
74  
88  
99  
10  
copy  
输出

99  
10  
71.29

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int n;
        int max=0,min=100;
        double aver;
        int grade;
        cin>>n;
        for(int i=1;i<=n;i++)
        {
        
            cin>>grade;
            aver+=grade;
            if(grade>max)
            {
        
                max=grade;
            }
            if(grade<min)
            {
        
                min=grade;
            }
        }
        cout<<max<<endl<<min<<endl;
        printf("%.2lf",aver/n);
    }

# 8、购物单 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。

这不，大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。

小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。

现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。

取款机只能提供  
100  
100 元面额的纸币。小明想尽可能少取些现金，够用就行了。 你的任务是计算出，小明最少需要取多少现金。

以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了。

\*\*\*\* 180.90 88折  
\*\*\*\* 10.25 65折  
\*\*\*\* 56.14 9折  
\*\*\*\* 104.65 9折  
\*\*\*\* 100.30 88折  
\*\*\*\* 297.15 半价  
\*\*\*\* 26.75 65折  
\*\*\*\* 130.62 半价  
\*\*\*\* 240.28 58折  
\*\*\*\* 270.62 8折  
\*\*\*\* 115.87 88折  
\*\*\*\* 247.34 95折  
\*\*\*\* 73.21 9折  
\*\*\*\* 101.00 半价  
\*\*\*\* 79.54 半价  
\*\*\*\* 278.44 7折  
\*\*\*\* 199.26 半价  
\*\*\*\* 12.97 9折  
\*\*\*\* 166.30 78折  
\*\*\*\* 125.50 58折  
\*\*\*\* 84.98 9折  
\*\*\*\* 113.35 68折  
\*\*\*\* 166.57 半价  
\*\*\*\* 42.56 9折  
\*\*\*\* 81.90 95折  
\*\*\*\* 131.78 8折  
\*\*\*\* 255.89 78折  
\*\*\*\* 109.17 9折  
\*\*\*\* 146.69 68折  
\*\*\*\* 139.33 65折  
\*\*\*\* 141.16 78折  
\*\*\*\* 154.74 8折  
\*\*\*\* 59.42 8折  
\*\*\*\* 85.44 68折  
\*\*\*\* 293.70 88折  
\*\*\*\* 261.79 65折  
\*\*\*\* 11.30 88折  
\*\*\*\* 268.27 58折  
\*\*\*\* 128.29 88折  
\*\*\*\* 251.03 8折  
\*\*\*\* 208.39 75折  
\*\*\*\* 128.88 75折  
\*\*\*\* 62.06 9折  
\*\*\*\* 225.87 75折  
\*\*\*\* 12.89 75折  
\*\*\*\* 34.28 75折  
\*\*\*\* 62.16 58折  
\*\*\*\* 129.12 半价  
\*\*\*\* 218.37 半价  
\*\*\*\* 289.69 8折  
copy  
需要说明的是，

88 折指的是按标价的

88 计算，而

8 折是按

80 计算，余者类推。 特别地，半价是按

50 计算。

请输出小明要从取款机上提取的金额，单位是元。

> AC代码：

#include <iostream>
    using namespace std;
    int main()
    {
        
      cout<<5200;
      return 0;
    }

# 9、空间 #

**本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。**

小蓝准备用

256MB 的内存空间开一个数组，数组的每个元素都是

32 位 二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问

256MB 的空间可以存储多少个

32 位二进制整数？

> AC代码：

#include <iostream>
    using namespace std;
    int main()
    {
        
      long long sum=256*1024*1024/4;
      cout<<sum;
      return 0;
    }

# 10、排序 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝最近学习了一些排序算法，其中冒泡排序让他印象深刻。

在冒泡排序中，每次只能交换相邻的两个元素。

小蓝发现，如果对一个字符串中的字符排序，只允许交换相邻的两个字符， 则在所有可能的排序方案中，冒泡排序的总交换次数是最少的。

例如，对于字符串  
�  
�  
�  
lan 排序，只需要  
1  
1 次交换。对于字符串  
�  
�  
�  
�  
qiao 排序，总共需要  
4  
4 次交换。

小蓝找到了很多字符串试图排序，他恰巧碰到一个字符串，需要  
100  
100 次交 换，可是他忘了吧这个字符串记下来，现在找不到了。

请帮助小蓝找一个只包含小写英文字母且没有字母重复出现的字符串，对 该串的字符排序，正好需要  
100  
100 次交换。如果可能找到多个，请告诉小蓝最短的那个。如果最短的仍然有多个，请告诉小蓝字典序最小的那个。

> AC代码：

#include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        
        int i,m,t,j;
        int n=0;
        while((n*n-n)/2<100)n++;
        m=(n*n-n)/2-100;
        char arr[n];
        for(i=0;i<n;i++)arr[i]=97+n-i-1;
        for(i=m;i>0;i--)
        {
        
            if(arr[i]<arr[i-1])
            {
        
                t=arr[i];
                arr[i]=arr[i-1];
                arr[i-1]=t;
            }
        }
        for(i=0;i<n;i++)
        {
        
            printf("%c",arr[i]);
        }
      return 0;
    }

# 11、跑步锻炼 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝每天都锻炼身体。

正常情况下，小蓝每天跑  
1  
1 千米。如果某天是周一或者月初（  
1  
1 日），为了激励自己，小蓝要跑  
2  
2 千米。如果同时是周一或月初，小蓝也是跑  
2  
2 千米。

小蓝跑步已经坚持了很长时间，从  
2000  
2000 年  
1  
1 月  
1  
1 日周六（含）到  
2020  
2020 年  
10  
10 月  
1  
1 日周四（含）。请问这段时间小蓝总共跑步多少千米？

> AC代码：

#include<iostream>
    using namespace std;
    int main()
    {
        
        int week[7]={
        6,7,1,2,3,4,5};
        int month[13]={
        0,31,0,31,30,31,30,31,31,30,31,30,31};
        int sum=0,day=0;
        for(int year=2000;year<=2020;year++)
        {
        
            if( (year%4==0&&year%100!=0) ||year%400==0  )
                month[2]=29;
            else
                month[2]=28;
            for(int i=1;i<=12;i++)
            {
        
                for(int j=1;j<=month[i];j++)
                {
        
                    if(week[day%7]==1||j==1)
                        sum++;
                    sum++;
                    day++;
                    if(year==2020&&i==10&&j==1)
                    {
        
                        cout<<sum;
                        return 0;
                    }
                } 
            } 
        }
    }

# 12、蛇形填数 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如下图所示，小明用从  
1  
1 开始的正整数“蛇形”填充无限大的矩阵。

1 2 6 7 15 …  
3 5 8 14 …  
4 9 13 …  
10 12 …  
11 …  
…  
copy  
容易看出矩阵第二行第二列中的数是  
5  
5。请你计算矩阵中第  
20  
20 行第  
20  
20 列的数是多少？

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int mp[101][101],row=0,col=0,cnt=1;
        mp[0][0]=1;
        while(!mp[19][19])
        {
        
            mp[row][++col]=++cnt;
            while(col)
            {
        
                mp[++row][--col]=++cnt;
            }
            mp[++row][col]=++cnt;
            while(row)
            {
        
                mp[--row][++col]=++cnt;
            } 
        }
        cout<<mp[19][19];
        return 0;
    }

# 13、递增序列 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

对于一个字母矩阵，我们称矩阵中的一个递增序列是指在矩阵中找到两个字母，它们在同一行，同一列，或者在同一  
45  
45 度的斜线上，这两个字母从左向右看、或者从上向下看是递增的。

例如，如下矩阵中

LANN  
QIAO  
copy  
有  
LN、LN、AN、AN、IO、AO、LQ、AI、NO、NO、AQ、IN、AN 等  
13  
13 个 递增序列。注意当两个字母是从左下到右上排列时，从左向右看和从上向下看 是不同的顺序。

对于下面的  
30  
30 行  
50  
50 列的矩阵，请问总共有多少个递增序列？

VLPWJVVNNZSWFGHSFRBCOIJTPYNEURPIGKQGPSXUGNELGRVZAG  
SDLLOVGRTWEYZKKXNKIRWGZWXWRHKXFASATDWZAPZRNHTNNGQF  
ZGUGXVQDQAEAHOQEADMWWXFBXECKAVIGPTKTTQFWSWPKRPSMGA  
BDGMGYHAOPPRRHKYZCMFZEDELCALTBSWNTAODXYVHQNDASUFRL  
YVYWQZUTEPFSFXLTZBMBQETXGXFUEBHGMJKBPNIHMYOELYZIKH  
ZYZHSLTCGNANNXTUJGBYKUOJMGOGRDPKEUGVHNZJZHDUNRERBU  
XFPTZKTPVQPJEMBHNTUBSMIYEGXNWQSBZMHMDRZZMJPZQTCWLR  
ZNXOKBITTPSHEXWHZXFLWEMPZTBVNKNYSHCIQRIKQHFRAYWOPG  
MHJKFYYBQSDPOVJICWWGGCOZSBGLSOXOFDAADZYEOBKDDTMQPA  
VIDPIGELBYMEVQLASLQRUKMXSEWGHRSFVXOMHSJWWXHIBCGVIF  
GWRFRFLHAMYWYZOIQODBIHHRIIMWJWJGYPFAHZZWJKRGOISUJC  
EKQKKPNEYCBWOQHTYFHHQZRLFNDOVXTWASSQWXKBIVTKTUIASK  
PEKNJFIVBKOZUEPPHIWLUBFUDWPIDRJKAZVJKPBRHCRMGNMFWW  
CGZAXHXPDELTACGUWBXWNNZNDQYYCIQRJCULIEBQBLLMJEUSZP  
RWHHQMBIJWTQPUFNAESPZHAQARNIDUCRYQAZMNVRVZUJOZUDGS  
PFGAYBDEECHUXFUZIKAXYDFWJNSAOPJYWUIEJSCORRBVQHCHMR  
JNVIPVEMQSHCCAXMWEFSYIGFPIXNIDXOTXTNBCHSHUZGKXFECL  
YZBAIIOTWLREPZISBGJLQDALKZUKEQMKLDIPXJEPENEIPWFDLP  
HBQKWJFLSEXVILKYPNSWUZLDCRTAYUUPEITQJEITZRQMMAQNLN  
DQDJGOWMBFKAIGWEAJOISPFPLULIWVVALLIIHBGEZLGRHRCKGF  
LXYPCVPNUKSWCCGXEYTEBAWRLWDWNHHNNNWQNIIBUCGUJYMRYW  
CZDKISKUSBPFHVGSAVJBDMNPSDKFRXVVPLVAQUGVUJEXSZFGFQ  
IYIJGISUANRAXTGQLAVFMQTICKQAHLEBGHAVOVVPEXIMLFWIYI  
ZIIFSOPCMAWCBPKWZBUQPQLGSNIBFADUUJJHPAIUVVNWNWKDZB  
HGTEEIISFGIUEUOWXVTPJDVACYQYFQUCXOXOSSMXLZDQESHXKP  
FEBZHJAGIFGXSMRDKGONGELOALLSYDVILRWAPXXBPOOSWZNEAS  
VJGMAOFLGYIFLJTEKDNIWHJAABCASFMAKIENSYIZZSLRSUIPCJ  
BMQGMPDRCPGWKTPLOTAINXZAAJWCPUJHPOUYWNWHZAKCDMZDSR  
RRARTVHZYYCEDXJQNQAINQVDJCZCZLCQWQQIKUYMYMOVMNCBVY  
ABTCRRUXVGYLZILFLOFYVWFFBZNFWDZOADRDCLIRFKBFBHMAXX

> AC代码：

#include <iostream>
    using namespace std;
    int main()
    {
        
      char v[30][51]={
        "VLPWJVVNNZSWFGHSFRBCOIJTPYNEURPIGKQGPSXUGNELGRVZAG",\
    "SDLLOVGRTWEYZKKXNKIRWGZWXWRHKXFASATDWZAPZRNHTNNGQF",\
    "ZGUGXVQDQAEAHOQEADMWWXFBXECKAVIGPTKTTQFWSWPKRPSMGA",\
    "BDGMGYHAOPPRRHKYZCMFZEDELCALTBSWNTAODXYVHQNDASUFRL",\
    "YVYWQZUTEPFSFXLTZBMBQETXGXFUEBHGMJKBPNIHMYOELYZIKH",\
    "ZYZHSLTCGNANNXTUJGBYKUOJMGOGRDPKEUGVHNZJZHDUNRERBU",\
    "XFPTZKTPVQPJEMBHNTUBSMIYEGXNWQSBZMHMDRZZMJPZQTCWLR",\
    "ZNXOKBITTPSHEXWHZXFLWEMPZTBVNKNYSHCIQRIKQHFRAYWOPG",\
    "MHJKFYYBQSDPOVJICWWGGCOZSBGLSOXOFDAADZYEOBKDDTMQPA",\
    "VIDPIGELBYMEVQLASLQRUKMXSEWGHRSFVXOMHSJWWXHIBCGVIF",\
    "GWRFRFLHAMYWYZOIQODBIHHRIIMWJWJGYPFAHZZWJKRGOISUJC",\
    "EKQKKPNEYCBWOQHTYFHHQZRLFNDOVXTWASSQWXKBIVTKTUIASK",\
    "PEKNJFIVBKOZUEPPHIWLUBFUDWPIDRJKAZVJKPBRHCRMGNMFWW",\
    "CGZAXHXPDELTACGUWBXWNNZNDQYYCIQRJCULIEBQBLLMJEUSZP",\
    "RWHHQMBIJWTQPUFNAESPZHAQARNIDUCRYQAZMNVRVZUJOZUDGS",\
    "PFGAYBDEECHUXFUZIKAXYDFWJNSAOPJYWUIEJSCORRBVQHCHMR",\
    "JNVIPVEMQSHCCAXMWEFSYIGFPIXNIDXOTXTNBCHSHUZGKXFECL",\
    "YZBAIIOTWLREPZISBGJLQDALKZUKEQMKLDIPXJEPENEIPWFDLP",\
    "HBQKWJFLSEXVILKYPNSWUZLDCRTAYUUPEITQJEITZRQMMAQNLN",\
    "DQDJGOWMBFKAIGWEAJOISPFPLULIWVVALLIIHBGEZLGRHRCKGF",\
    "LXYPCVPNUKSWCCGXEYTEBAWRLWDWNHHNNNWQNIIBUCGUJYMRYW",\
    "CZDKISKUSBPFHVGSAVJBDMNPSDKFRXVVPLVAQUGVUJEXSZFGFQ",\
    "IYIJGISUANRAXTGQLAVFMQTICKQAHLEBGHAVOVVPEXIMLFWIYI",\
    "ZIIFSOPCMAWCBPKWZBUQPQLGSNIBFADUUJJHPAIUVVNWNWKDZB",\
    "HGTEEIISFGIUEUOWXVTPJDVACYQYFQUCXOXOSSMXLZDQESHXKP",\
    "FEBZHJAGIFGXSMRDKGONGELOALLSYDVILRWAPXXBPOOSWZNEAS",\
    "VJGMAOFLGYIFLJTEKDNIWHJAABCASFMAKIENSYIZZSLRSUIPCJ",\
    "BMQGMPDRCPGWKTPLOTAINXZAAJWCPUJHPOUYWNWHZAKCDMZDSR",\
    "RRARTVHZYYCEDXJQNQAINQVDJCZCZLCQWQQIKUYMYMOVMNCBVY",\
    "ABTCRRUXVGYLZILFLOFYVWFFBZNFWDZOADRDCLIRFKBFBHMAXX"};
      int s=0;
      for(int i=0;i<30;i++)
        for(int j=0;j<50;j++)
          for(int x=0;x<30;x++)
            for(int y=0;y<50;y++)
              if(v[i][j]<v[x][y]&&((i==x&&y>j)||(j==y&&x>i)||abs(y-j)==abs(x-i)&&!(x<=i&&y<=j)))
                s++;
      cout<<s;
    }

# 14、货物摆放 #

**题目描述**  
小蓝有一个超大的仓库，可以摆放很多货物。

现在，小蓝有

n 箱货物要摆放在仓库，每箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都必须严格平行于长、宽、高。

小蓝希望所有的货物最终摆成一个大的长方体。即在长、宽、高的方向上分别堆

L、W、H 的货物,满足

n=L×W×H。

给定

n，请问有多少种堆放货物的方案满足要求。

例如，当

4  
n=4 时，有以下  
6  
6 种方案：  
1×1×4、1×2×2、1×4×1、2×1×2、2×2×1、4×1×1。

请问，当

2021041820210418  
n=2021041820210418 （注意有  
16  
16 位数字）时，总共有多少种方案？

提示：建议使用计算机编程解决问题。

答案提交  
**这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。**

> AC代码：

#include<iostream>
    #include<cmath>
    #include<vector>
    using namespace std;
    int main()
    {
        
        long long n=2021041820210418;
        vector<long long>divisor;
        for(long long i=1;i<=sqrt(n);i++)
        {
        
            if(n%i==0)
            {
        
                divisor.push_back(i);
                long long k=n/i;
                if(k!=i)
                    divisor.push_back(k);
            }
        }
        int count=0;
        vector<long long>::iterator a,b,c;
        for(a=divisor.begin();a!=divisor.end();a++)
        {
        
            for(b=divisor.begin();b!=divisor.end();b++)
            {
        
                for(c=divisor.begin();c!=divisor.end();c++)
                {
        
                    if((*a)*(*b)*(*c)==n)
                        count++;
                }
            }
        }
        cout<<count<<endl;
        return 0;
    }

# 15、九进制转十进制 #

**问题描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

九进制正整数  
(  
2022  
)  
9  
(2022)  
9  
  
转换成十进制等于多少？

> AC代码：

#include <iostream>
    using namespace std;
    int main()
    {
        
      cout<<2+2*9+2*9*9*9;
      return 0;
    }

# 16、等差素数列 #

**题目描述**  
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

2,3,5,7,11,13,… 是素数序列。 类似：

7,37,67,97,127,157 这样完全由素数组成的等差数列，叫等差素数数列。

上边的数列公差为 30，长度为 6

2004 年，格林与华人陶哲轩合作证明了：存在任意长度的素数等差数列。 这是数论领域一项惊人的成果！

有这一理论为基础，请你借助手中的计算机，满怀信心地搜索：

长度为

10 的等差素数列，其公差最小值是多少？

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    bool judge(int x)
    {
        
        for(int i=2;i<x;i++)
        {
        
            if(x%i==0)
                return false;
        }
        return true;
    }
    int main()
    {
        
        int ans=1,num,d;
        for(int i=2;i<50000;i++)
        {
        
            if(judge(i))
            {
        
                for(int d=1;d<1000;d++)
                {
        
                    for(int j=1;j<1000;j++)
                    {
        
                        num=i+d*j;
                        if(judge(num))
                            ans++;
                        else
                        {
        
                            ans=1;
                            break;
                        }
                        if(ans==10)
                        {
        
                            cout<<d;
                            return 0;
                        }
                    }
                }
            }
        }
    }

# 17、七段码 #

**题目描述**  
**本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。**

小蓝要用七段码数码管来表示一种特殊的文字。  
![在这里插入图片描述][3b62f13b6d6a42dc8ecf0c0a12018aa5.png]  
上图给出了七段码数码管的一个图示，数码管中一共有  
7  
7 段可以发光的二 极管，分别标记为

a,b,c,d,e,f,g。

小蓝要选择一部分二极管（至少要有一个）发光来表达字符。在设计字符 的表达时，要求所有发光的二极管是连成一片的。

例如：

b 发光，其他二极管不发光可以用来表达一种字符。

例如

c 发光，其他二极管不发光可以用来表达一种字符。这种方案与上 一行的方案可以用来表示不同的字符，尽管看上去比较相似。

例如：

a,b,c,d,e 发光，

f,g 不发光可以用来表达一种字符。

例如：

b,f 发光，其他二极管不发光则不能用来表达一种字符，因为发光 的二极管没有连成一片。

请问，小蓝可以用七段码数码管表达多少种不同的字符？

> AC代码：

#include <iostream>
    using namespace std;
    
    int BackTrack(int graph[][7],int visit[],int n,int i){
        
      int count=1;
      for(int x=0;x<n;x++){
        
        if(visit[x]!=1&&graph[i][x]!=0){
        
          visit[x]=1;
          count+=BackTrack(graph,visit,n,x);
          visit[x]=0;
        }
      }
      return count;
    }
    int main()
    {
        
      int graph[7][7]={
        
        {
        1,1,0,0,0,1,0},
        {
        1,1,1,0,0,0,1},
        {
        0,1,1,1,0,0,1},
        {
        0,0,1,1,1,0,0},
        {
        0,0,0,1,1,1,1},
        {
        1,0,0,0,1,1,1},
        {
        0,1,1,0,1,1,1}
      };
      int visit[7]={
        0};
      printf("%d",BackTrack(graph,visit,7,0)/2);
      return 0;
    }

# 18、跳跃 #

**题目描述**  
小蓝在一个  
�  
n 行  
�  
m 列的方格图中玩一个游戏。

开始时，小蓝站在方格图的左上角，即第  
1  
1 行第  
1  
1 列。

小蓝可以在方格图上走动，走动时，如果当前在第  
�  
r 行第  
�  
c 列，他不能走到行号比  
�  
r 小的行，也不能走到列号比  
�  
c 小的列。同时，他一步走的直线距离不超过  
3  
3。

例如，如果当前小蓝在第  
3  
3 行第  
5  
5 列，他下一步可以走到第  
3  
3 行第  
6  
6 列、第  
3  
3 行第  
7  
7 列、第  
3  
3 行第  
8  
8 列、第  
4  
4 行第  
5  
5 列、第  
4  
4 行第  
6  
6 列、第  
4  
4 行第  
7  
7 列、第  
5  
5 行第  
5  
5 列、第  
5  
5 行第  
6  
6 列、第  
6  
6 行第  
5  
5 列之一。

小蓝最终要走到第  
�  
n 行第  
�  
m 列。

在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。

小蓝希望，从第  
1  
1 行第  
1  
1 列走到第  
�  
n 行第  
�  
m 列后，总的权值和最大。请问最大是多少？

输入描述  
输入的第一行包含两个整数  
�  
,  
�  
n,m，表示图的大小。

接下来  
�  
n 行，每行  
�  
m 个整数，表示方格图中每个点的权值。

其中，  
1  
≤  
�  
≤  
100  
，  
−  
1  
0  
4  
≤  
权值  
≤  
1  
0  
4  
1≤n≤100，−10  
4  
≤权值≤10  
4  
。

输出描述  
输出一个整数，表示最大权值和。

输入输出样例  
示例 1  
输入

3 5  
\-4 -5 -10 -3 1  
7 5 -9 3 -10  
10 -2 6 -10 -4  
copy  
输出

> AC代码：

#include<bits/stdc++.h>
    using namespace std;
    int main()
    {
        
        int n,m,trans;
        cin>>n>>m;
        int grapth[n+1][m+1];
        int x[9]={
        0,0,0,-1,-1,-1,-2,-2,-3};
        int y[9]={
        -1,-2,-3,0,-1,-2,-1,0};
        for(int i=1;i<=n;i++)
        {
        
            for(int j=1;j<=m;j++)
            {
        
                cin>>grapth[i][j];
                trans=INT_MIN;
                for(int t=0;t<9;t++)
                {
        
                    if(i+x[t]>0&&j+y[t]>0)
                        trans=max(trans,grapth[i+x[t]][j+y[t]]);
                }
                if(trans!=INT_MIN)
                    grapth[i][j]+=trans;
            }
            
        }
        cout<<grapth[n][m]<<endl;
    }

# 19、时间显示 #

**题目描述**  
小蓝要和朋友合作开发一个时间显示的网站。

在服务器上，朋友已经获取了当前的时间，用一个整数表示，值为从  
1970  
1970 年  
1  
1 月  
1  
1 日  
00  
:  
00  
:  
00  
00:00:00 到当前时刻经过的毫秒数。

现在，小蓝要在客户端显示出这个时间。小蓝不用显示出年月日，只需要显示出时分秒即可，毫秒也不用显示，直接舍去即可。

给定一个用整数表示的时间，请将这个时间对应的时分秒输出。

输入描述  
输入一行包含一个整数，表示时间。

输出描述  
输出时分秒表示的当前时间，格式形如 HH:MM:SS，其中 HH 表示时，值为  
0  
0 到  
23  
23，MM 表示分，值为  
0  
0 到  
59  
59，SS 表示秒，值为  
0  
0 到  
59  
59。时、分、秒 不足两位时补前导  
0  
0。

输入输出样例  
示例 1  
输入

46800999  
copy  
输出

13:00:00  
copy  
示例 2  
输入

1618708103123  
copy  
输出

01:08:23  
copy  
评测用例规模与约定  
对于所有评测用例，给定的时间为不超过  
1  
0  
18  
10  
18  
的正整数。

> AC代码：

#include<iostream>
    using namespace std;
    int main()
    {
        
        long long sum;
        cin>>sum;
        int hh,mm,ss;
        sum/=1000;
        hh=sum/60/60%24;
        mm=sum/60%60;
        ss=sum%60;
        printf("%02d:%02d:%02d",hh,mm,ss);
    }

[da8f1c713e47435b9efdf4ca12b026fc.png]: https://img-blog.csdnimg.cn/da8f1c713e47435b9efdf4ca12b026fc.png
[bb9ba0adff3d4fb2aa50dab49091e637.png]: https://img-blog.csdnimg.cn/bb9ba0adff3d4fb2aa50dab49091e637.png
[755f3dfa8e2d4ca0813ad772475dc644.png]: https://img-blog.csdnimg.cn/755f3dfa8e2d4ca0813ad772475dc644.png
[3b62f13b6d6a42dc8ecf0c0a12018aa5.png]: https://img-blog.csdnimg.cn/3b62f13b6d6a42dc8ecf0c0a12018aa5.png