蓝桥杯校内模拟赛Python解答
@
1. 15.125GB
【问题描述】
在计算机存储中，15.125GB是多少MB？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
1KiB（Kilobyte）=1024B ，即2的10次方字节zd，读音“千字节”
1MiB（Megabyte）=1024KiB，即2的20次方字内节，读音“兆字节”
1GiB（Gigabyte）=1024MiB，即2的30次方字节，读音“吉字节”
1TiB（Terabyte）=1024GiB，即2的40次方字节容，读音“太字节”
1PiB（Petabyte）=1024TiB，即2的50次方字节，读音“拍字节”
1EiB（Exabyte） =1024PiB，即2的60次方字节，读音“艾字节”
1ZiB（Zettabyte）=1024EiB，即2的70次方字节，读音“Z字节”
1YiB（Yottabyte）=1024ZiB，即2的80次方字节，读音“Y字节
比特(bit)是最小的存储单位。
计算机存储单位一般用字节(Byte)、千字节(KB)、兆字节(MB)、吉字节(GB)、太字节(TB)、拍字节(PB)、艾字节(EB)、泽它字节(ZB，又称皆字节)、尧它字节(YB)表示。
capacity = 15.125 * 1024
print(capacity)
15488
2. 约数个数
【问题描述】
1200000有多少个约数（只计算正约数）。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
约数，又叫因数。整数a除以整数b(b≠0) 除得的商正好是整数而没有余数，我们就说a能被b整除，或b能整除a。a称为b的倍数，b称为a的约数。在自然数（0和正整数）的范围内，任何正整数都是0的约数。4的正约数有：1、2、4。6的正约数有：1、2、3、6。10的正约数有：1、2、5、10。12的正约数有：1、2、3、41215的正约数有：1、3、5、15。18的正约数有：1、2、3、6、9、18。20的正约数有：1、2、4、5、10、20。注意：一个数的约数必然包括1及其本身。
count = 2 # 1 and itself
num = 1200000
for i in range(2, num): # From 2 to num - 1
if num % i == 0:
count += 1
# print(i, end=' ') # Show all divisors
print(count)
96
3. 叶结点数
【问题描述】
一棵包含有2019个结点的二叉树，最多包含多少个叶结点？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
最多叶子结点数就是求其对应的完全二叉树
然后求2019个结点的完全二叉树的叶子结点即可
def most_leaf_nodes(total):
layer = 0
while 2 ** layer - 1 < total:
layer += 1
now_layer = layer - 1
now_layer_nodes = 2 ** (layer - 2)
now_total_nodes = 2 ** (layer - 1) - 1
left_nodes = total - now_total_nodes
leaf_nodes = now_layer_nodes - (left_nodes // 2 + left_nodes % 2) + left_nodes
return leaf_nodes
print(most_leaf_nodes(2019))
1010
4. 数字9
【问题描述】
在1至2019中，有多少个数的数位中包含数字9？
注意，有的数中的数位中包含多个9，这个数只算一次。例如，1999这个数包含数字9，在计算只是算一个数。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
数位分离
def is_contains_9(num):
"""It's four, no need to cycle."""
one = num % 10
ten = num // 10 % 10
hundred = num // 100 % 10
thousand = num // 1000 % 10
if 9 in [one, ten, hundred, thousand]:
return True
else:
return False
ans = 0
given_number = 2019
for i in range(1, given_number + 1):
if is_contains_9(i):
# print(i, end=' ') # list all eligible numbers
ans += 1
print('\n', ans, sep='')
544
5. 数位递增的数
【问题描述】
一个正整数如果任何一个数位不大于右边相邻的数位，则称为一个数位递增的数，例如1135是一个数位递增的数，而1024不是一个数位递增的数。
给定正整数 n，请问在整数 1 至 n 中有多少个数位递增的数？
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
30
【样例输出】
26
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n <= 1000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000。
dp动态规划
def dfs(pos, pre, limit):
if pos == -1: # 单独一位算一个
return 1
if not limit and dp[pos][pre] != -1: # 返回dp二维表中记录的值
return dp[pos][pre]
up = a[pos] if limit else 9
ans = 0
for i in range(pre, up + 1):
ans += dfs(pos - 1, i, limit and i == a[pos])
if not limit: # 把算过的值记录在dp二维表中
dp[pos][pre] = ans
return ans
def solve(num):
k = 0
while num != 0:
a[k] = num % 10
k += 1
num = num // 10
return dfs(k - 1, 0, True)
a = [0 for _ in range(10)]
dp = [[-1 for _ in range(10)] for _ in range(11)]
n = int(input())
print(solve(n) - 1)
# print(a, dp, sep='\n')
当输入1000时，数组中数据记录
1000
219
[0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
[[10, 9, 8, 7, 6, 5, 4, 3, 2, 1],
[55, 45, 36, 28, 21, 15, 10, 6, 3, 1],
[220, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1]]
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。
按顺序比大小，用过的中心入栈，之后就不能再用了
n = int(input())
arr = list(map(int, input().split()))
count = 0
data = []
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
if arr[i] < arr[j] < arr[k]:
if arr[j] not in data:
data.append(arr[j])
count += 1
# count += 1
# arr[j] = 0
print(count)
7. 音节判断
【问题描述】
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出答案，或者为yes，或者为no。
【样例输入】
lanqiao
【样例输出】
yes
【样例输入】
world
【样例输出】
no
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。
这里直接列出了 也可以自己编一个判断函数
word = input()
vowel = ['a', 'e', 'i', 'o', 'u']
i = 0
ans = 0
if word[i] in vowel:
print('no')
else:
ans += 1
i += 1
while i < len(word):
if word[i] not in vowel:
i += 1
else:
ans += 1
# print(ans, i)
break
while i < len(word):
if word[i] in vowel:
i += 1
else:
ans += 1
# print(ans, i)
break
while i < len(word):
if word[i] not in vowel:
i += 1
else:
ans += 1
# print(ans, i)
break
while i < len(word):
if word[i] in vowel:
i += 1
else:
ans += 1
break
if ans == 4:
print('yes')
else:
print('no')
8. 长草
【问题描述】
小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。
小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。
这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。
请告诉小明，k 个月后空地上哪些地方有草。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 g，表示种了草。
接下来包含一个整数 k。
【输出格式】
输出 n 行，每行包含 m 个字母，表示 k 个月后空地的状态。如果为小数点，表示为空地，如果字母为 g，表示长了草。
【样例输入】
4 5
.g...
.....
..g..
.....
2
【样例输出】
gggg.
gggg.
ggggg
.ggg.
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20。
对于 70% 的评测用例，2 <= n, m <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= k <= 1000。
输出二位列表元素
for i in range(n)：
print(arr[i], sep='')
输出一维列表元素
print(arr, sep='')
此处arr为一维数组
def grow_grass(x, y):
for q in range(4):
tx = x + next_[q][0]
ty = y + next_[q][1]
if tx >= 0 and tx < n and ty >= 0 and ty < m: # 不能越界
if arr[tx][ty] == '.': # 如果本来就有草，则不动，无草，才长
arr[tx][ty] = 'g'
flag[tx][ty] = 1
n, m = map(int, input().split())
arr = [list(input()) for _ in range(n)]
flag = [[0 for _ in range(m)] for _ in range(n)]
next_ = [[-1, 0], [1, 0], [0, -1], [0, 1]] # 用来表示(x, y)的上下左右四个位置
k = int(input())
# print(arr)
# exit()
for i in range(k):
flag = [[0 for _ in range(m)] for _ in range(n)]
for j in range(n):
for p in range(m):
if arr[j][p] == 'g' and flag[j][p] == 0:
# print(j, p)
flag[j][p] = 1
grow_grass(j, p)
for i in range(n):
print(*arr[i], sep='')
# print(arr)
# print(flag)
9. 序列计数
【问题描述】
小明想知道，满足以下条件的正整数序列的数量：
1. 第一项为 n；
2. 第二项不超过 n；
3. 从第三项开始，每一项小于前两项的差的绝对值。
请计算，对于给定的 n，有多少种满足条件的序列。
【输入格式】
输入一行包含一个整数 n。
【输出格式】
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
【样例输入】
4
【样例输出】
7
【样例说明】
以下是满足条件的序列：
4 1
4 1 1
4 1 2
4 2
4 2 1
4 3
4 4
【评测用例规模与约定】
对于 20% 的评测用例，1 <= n <= 5；
对于 50% 的评测用例，1 <= n <= 10；
对于 80% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 1000。
有难度
解释在代码注释中
def next_item(res):
res_ = []
size = len(res)
ab = abs(res[size - 1] - res[size - 2])
if ab <= 1:
return None
for i in range(1, ab):
new_res = []
new_res += res
new_res.append(i)
res_.append(new_res)
return res_
MOD = 10000
n = int(input())
res_list = []
temp_list = []
accept_list = []
for i in range(1, n + 1):
res = [n, i] # 两项时的情况
res_list.append(res) # 把所有两项情况加入res_list记录
temp_list += res_list # 把res_list记录进temp_list
while len(temp_list) > 0:
for i in range(len(temp_list)): # 判断temp_list的每一项
next_ = next_item(temp_list[i]) # 判断这项可以再派生下一项
# print(next_)
if next_ is not None: # 如果可以派生下一项，添加记录到accept_list
accept_list += next_
temp_list.clear() # 清空
if len(accept_list) != 0:
# print(accept_list)
# print(res_list)
res_list = accept_list + res_list # 把新派生出的项加到res_list，res_list此时已包含两项加新派生的项
# print(res_list)
temp_list += accept_list # 新派生的项加到temp_list进行下次循环用
accept_list.clear()
# print(res_list) # 循环结束后，此时所有满足条件的项都在res_list中
print(len(res_list) % MOD)
10. 晚会节目单
【问题描述】
小明要组织一台晚会，总共准备了 n 个节目。然后晚会的时间有限，他只能最终选择其中的 m 个节目。
这 n 个节目是按照小明设想的顺序给定的，顺序不能改变。
小明发现，观众对于晚上的喜欢程度与前几个节目的好看程度有非常大的关系，他希望选出的第一个节目尽可能好看，在此前提下希望第二个节目尽可能好看，依次类推。
小明给每个节目定义了一个好看值，请你帮助小明选择出 m 个节目，满足他的要求。
【输入格式】
输入的第一行包含两个整数 n, m ，表示节目的数量和要选择的数量。
第二行包含 n 个整数，依次为每个节目的好看值。
【输出格式】
输出一行包含 m 个整数，为选出的节目的好看值。
【样例输入】
5 3
3 1 2 5 4
【样例输出】
3 5 4
【样例说明】
选择了第1, 4, 5个节目。
【评测用例规模与约定】
对于 30% 的评测用例，1 <= n <= 20；
对于 60% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 100000，0 <= 节目的好看值 <= 100000。
尽可能的好看，表示贪心
每次开始选的时候都要选可选择的值中的表示最好看的值
第一次选只能从前n - m 个中选择
之后则从选出的值对应的索引序号后开始到n - m + count中选
选出的值放入items列表中
当items列表长度小于n - m时开始循环
选满m个值后结束循环
提示：
输出列表直接元素，不带两侧的列表符号
print(*items)
下面这样输出的会带列表符号
print(items)
n, m = map(int, input().split())
count = 1
values = list(map(int, input().split()))
items = [max(values[:n - m + 1])]
max_i = values.index(items[0])
while len(items) < m:
items.append(max(values[max_i + 1:n-m+count+1]))
max_i = values.index(items[count])
count += 1
print(*items)
找了两组测试数据
Example 1:
8 5
1 2 3 5 7 8 10 9
5 7 8 9 10
Example 2:
9 4
1 2 8 5 7 6 3 9 4
8 7 9 4
