第十一届蓝桥杯校内模拟赛
# 题目
# 1. 15.125GB
# 问题描述
【问题描述】
在计算机存储中，15.125GB是多少MB？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
# 题解
此题和蓝桥杯第11次大赛的第一天相似，15.125GB = 15.125 * 1024 MB = 15,488MB
| 1B | = | 8bit |
| 1KB | = | 1024B |
| 1MB | = | 1024KB |
| 1GB | = | 1024MB |
| 1TB | = | 1024GB |
# 答案
15488
# 2. 约数个数
【问题描述】
1200000有多少个约数（只计算正约数）。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
# 题解
要求约数的个数，可以从一循环到1200000，统计出能够被1200000整除的数字的个数。
#include <iostream>
using namespace std;
int main(){
int cnt;
for(int i = 1;i<=1200000;i++){
if(1200000 % i == 0)
cnt++;
}
cout << cnt << endl;
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
# 答案
96
# 3. 叶结点数
# 问题描述
【问题描述】
一棵包含有2019个结点的二叉树，最多包含多少个叶结点？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
# 题解
二叉树的一个性质是第 i 层上最多有 2^i-1 个结点(i>=1)，这样我们可以得出二叉树每一层的结点个数，叶结点是没有左右子树的，所以我们首先需要知道第2019个结点在二叉树上的位置，才能得到最后的答案。
#include <iostream>
#include <math.h>
//#include<bits/stdc++.h>
using namespace std;
int main(){
double n;
int i;
double cnt = 0;
cin >> n;
for(i = 1; cnt <= n; i++){
cnt = pow(2.0,i-1) + cnt;
}
cout << i-1;
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
这段代码可以求出第 N 个结点在二叉树的第几层，i 代表层数，可以求出第2019个结点在二叉树的第十一层，第一层到第十层共计有 2^0 + 2^1 + 2^2 + ... + 2^9 = 1023 个结点，第一层到第十一层共有 2047 个结点。确定了第 2019 个结点在第十一层，那么第 2019 个结点在第十一层的哪里呢? 前十层占据了1023 个结点，那么就可以知道第 2019 个结点在第十一层的第 2019 - 1023 个位置处。也就是第 996 个结点，第十一层的 996 个结点占据了第十层的 996 / 2 个结点，也就是第十层有 498 个父结点，那么第十层一共有 512 个结点，其中有 498 个有叶子结点，那么还剩 512 - 498(14) 个叶子节点，总共的叶子结点就是第十一层的 996 个加上第十层的 14 个，一共 1010 个叶子节点。所以答案为1010。
# 答案
1010
# 4. 数字9
# 问题描述
【问题描述】
在1至2019中，有多少个数的数位中包含数字9？
注意，有的数中的数位中包含多个9，这个数只算一次。例如，1999这个数包含数字9，在计算只是算一个数。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
# 题解
#include <bits/stdc++.h>
using namespace std;
int main(){
int cnt = 0;
int n = 2019;
while(n--){
string s = to_string(n); //to_string 编译时需要c++11支持
if(s.find('9') != string::npos)
cnt++;
}
cout << cnt;
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 答案
543
# 5. 数位递增的数
# 问题描述
【问题描述】
一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
30
【样例输出】
26
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n <= 1000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
# 思路
借助于转化字符串方便的原因，我们把数字转化为字符串，然后两两相邻的数字比较，若出现前面的数字小于后面的就可以确定这个数字不是递增的数，统计数量即可。
# 源代码
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, cnt = 0;
cin >> n;
for(int i = 1;i <= n;i++){
string s = to_string(i);
bool flag = true;
for(int j = 0; j < s.length() -1;j++){
if(s[j] > s[j + 1])
flag = false;
break;
}
if(flag)
cnt++;
}
cout << cnt;
return 0;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 6. 递增三元组
# 问题描述
【问题描述】
在数列 a[1], a[2], ..., a[n] 中，如果对于下标 i, j, k 满足 0<i<j<k<n+1 且 a[i]<a[j]<a[k]，则称 a[i], a[j], a[k] 为一组递增三元组，a[j]为递增三元组的中心。
给定一个数列，请问数列中有多少个元素可能是递增三元组的中心。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[1], a[2], ..., a[n]，相邻的整数间用空格分隔，表示给定的数列。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
5
1 2 5 3 5
【样例输出】
2
【样例说明】
a[2] 和 a[4] 可能是三元组的中心。
【评测用例规模与约定】
对于 50% 的评测用例，2 <= n <= 100，0 <= 数列中的数 <= 1000。
对于所有评测用例，2 <= n <= 1000，0 <= 数列中的数 <= 10000。
# 思路
本题有规定评测用例规模，对于 50% 的用例 2 <= n <= 100，0 <= 数列中的数 <= 1000。则证明如果用暴力法，最多得到一半的分数。如果实在没有思路的话可以用暴力法。暴力法需要三重循环，如果不用暴力法的话，就需要一些技巧。
# 源代码
暴力法(三重循环)
#include <iostream>
#include <algorithm>
using namespace std;
int a[1005];
int b[1005];
int main()
{
int n, ans = 0;//计数
int ind = 1;//用于存放符合条件的三元组中心的下标
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n - 2; i++)
{
for (int j = i + 1; j <= n - 1; j++)
{
for (int k = j + 1; k <= n; k++)
{
//如果满足题意，则将三元组中心的下标存入数组中
if (a[i] < a[j] && a[j] < a[k])
{
b[ind++] = j;
}
}
}
}
//对存放入数组中的不同下标进行计数
sort(b, b + ind);
for (int i = 1; i < ind; i++)
{
if (b[i] != b[i - 1]) ans++;
}
cout << ans;
return 0;
}
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
双重循环
#include <iostream>
using namespace std;
const int N = 1005;
int n, p[N], ans;
bool ok(int x) {
bool ok = false; //初始化 ok 的值
for (int i = x - 1; i >= 1; i--) {
if (p[i] < p[x]) { //判断 x 前面是否存在小于p[x]的的元素
ok = true; break; //若存在，ok=true,退出循环，因为只要找到一个是小于 x 的就行，不用一直循环到p数组的第一个元素
}
}
if (!ok) return false; //判断 x 前面是否有比p[x]小的元素，如果没有则直接返回false,证明没有递增三元组
for (int i = x + 1; i <= n; i++) {
if (p[x] < p[i]) return true; //判断 x 后面是否有大于p[x]的元素
}
return false;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i]; //数据的输入，下标从 1 开始
}
for (int i = 1; i <= n; i++) {
if (ok(i)) ans++;
}
cout << ans;
return 0;
}
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
# 7. 音节判断
# 问题描述
【问题描述】
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出答案，或者为yes，或者为no。
【样例输入】
lanqiao
【样例输出】
yes
【样例输入】
world
【样例输出】
no
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。
# 思路
结构为辅音元音辅音元音的单词输出 yes ,否则输出 no ,则可以一个一个的判断。
# 源代码
#include <bits/stdc++.h>
using namespace std;
bool ok(char c){
if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
return true;
return false;
}
int main(){
string str;
int step = 0;
cin >> str;
for(int i = 0;i < str.size();i++){
if(step == 0){
if(!ok(str[i])) step = 1; //判断第一段是否为辅音,如果是辅音则step = 1，是元音的话则继续判断下一个字符
}
if(step == 1){
if(ok(str[i])) step = 2; //判断第二段是否为元音,如果是元音就step = 2, 是辅音的话则判断下一个字符
}
if(step == 2){
if(!ok(str[i])) step = 3; //判断第三段是否为辅音,如果是辅音则step = 1，是元音的话则继续判断下一个字符
}
if(step = 3){
if(ok(str[i])) step = 4; //判断第四段是否为辅音,如果是辅音则step = 1，是元音的话则继续判断下一个字符
}
}
if(step == 4)
cout << "yes" <<endl;
else
cout << "no" <<endl;
return 0;
}
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