蓝桥杯校内模拟赛Python解答

1. 15.125GB
2. 约数个数
3. 叶结点数
4. 数字9
5. 数位递增的数
6. 递增三元组
7. 音节判断
8. 长草
9. 序列计数
10. 晚会节目单

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)

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