校内模拟赛（完结）

文章目录

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

数据结构方法：

class Node:
    def __init__(self, item):
        self.item = item
        self.left = None
        self.right = None


class Queue:
    def __init__(self):
        self.items = []

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if not self.isEmpty():
            return self.items.pop(0)
        else:
            print('空队列')

    def isEmpty(self):
        return self.items == []


class Tree:
    def __init__(self):
        self.root = None

    def addNode(self, item):
        node = Node(item)
        cur = self.root
        if cur is None:
            self.root = node
            return
        queue = Queue()
        queue.enqueue(cur)
        while not queue.isEmpty():
            nd = queue.dequeue()
            if nd.left is None:
                nd.left = node
                return
            else:
                queue.enqueue(nd.left)
            if nd.right is None:
                nd.right = node
                return
            else:
                queue.enqueue(nd.right)

    def travel(self):
        cur = self.root
        queue = Queue()
        queue.enqueue(cur)
        while not queue.isEmpty():
            nd = queue.dequeue()
            print(nd.item)
            if nd.left is not None:
                queue.enqueue(nd.left)
            if nd.right is not None:
                queue.enqueue(nd.right)

    def findLeaf(self):
        count = 0
        cur = self.root
        queue = Queue()
        queue.enqueue(cur)
        while not queue.isEmpty():
            nd = queue.dequeue()
            if nd.left is None and nd.right is None:
                count += 1
            else:
                if nd.left is not None:
                    queue.enqueue(nd.left)
                if nd.right is not None:
                    queue.enqueue(nd.right)
        return count


def main():
    n = 2019
    tree = Tree()
    for i in range(1, n+1):
        tree.addNode(i)
    # tree.travel()
    print(tree.findLeaf())


if __name__ == '__main__':
    main()  # 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动态规划
暴力解法也可以，但是注意不要用python自带的函数，那样会增加运行时间，例如列表的排序sort函数，倒置reverse函数，range能不用也可以减少时间

暴力解法（这里如果要出现列表排序之类的话，时间就会超出1s之外）：

import time

# 不要使用python内置的排序函数等，否则会超时
# n = int(input())

start = time.time()


def solve(num):
    pre = 9
    while num != 0:
        now = num % 10
        num = num // 10
        # 这里如果你数位分离后存入一个列表再对列表进行遍历比较大小则会造成时间超出1s
        # 因为遍历需要用到range函数
        # 如果你存入列表后用排序函数sorted得到一个新列表与原列表笔较是否相同也会超出1s
        if now <= pre:
            pre = now
        else:
            return False
    return True


count = 0

for i in range(1, 1000000+1):
    if solve(i):
        count += 1
print(count)

end = time.time()
print(end - start)
# n = 1000000 时间为0.34078240394592285s

递归解法

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]]

import time


n = int(input())

start = time.time()
# count = 0
ls = []

for i in range(1, n+1):
    num = i
    lst = []
    while num != 0:
        lst.append(num % 10)
        num = num // 10
    lst.reverse()
    new_lst = sorted(lst)
    if new_lst == lst:
        # count += 1
        ls.append(i)
# print(count)
print(len(ls))
# print(ls)
end = time.time()
print(end - start)
# n = 1000000 时间为1.4426355361938477s

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()))
record = set()

for i in range(n-2):
    for j in range(i, n-1):
        for k in range(j, n):
            if arr[i] < arr[j] < arr[k]:
                record.add(arr[j])

# print(record)
print(len(record))

7. 音节判断

【问题描述】
小明对类似于 hello 这种单词非常感兴趣，这种单词可以正好分为四段，第一段由一个或多个辅音字母组成，第二段由一个或多个元音字母组成，第三段由一个或多个辅音字母组成，第四段由一个或多个元音字母组成。
给定一个单词，请判断这个单词是否也是这种单词，如果是请输出yes，否则请输出no。
元音字母包括 a, e, i, o, u，共五个，其他均为辅音字母。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出答案，或者为yes，或者为no。
【样例输入】
lanqiao
【样例输出】
yes
【样例输入】
world
【样例输出】
no
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。

这里直接列出了也可以自己编一个判断函数
补增函数版本的

def is_yuan(c):
    if c in ['a', 'e', 'i', 'o', 'u']:
        return True
    else:
        return False


def yuan():
    global pos
    ans = 0
    while pos < len(s):
        if is_yuan(s[pos]):
            pos += 1
            ans += 1
        else:
            break
    return ans


def zhuo():
    global pos
    ans = 0
    # 0 为False 非0为True
    # 一共四段，如果哪段ans为0，则那段不符合规则
    while pos < len(s):
        if is_yuan(s[pos]):
            break
        pos += 1
        ans += 1
    return ans


def search():
    if zhuo() and yuan() and zhuo() and yuan() and pos == len(s):
        return True
    else:
        return False


pos = 0
s = input()

if search():
    print('yes')
else:
    print('no')

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。

有难度
解释在代码注释中

import sys
sys.setrecursionlimit(10000)
def dfs(old, now):
    if now <= 0:
        return 0
    if hx[old][now] != 0:
        return hx[old][now]
    hx[old][now] = (1 + dfs(old, now - 1) + dfs(now, abs(old - now) - 1)) % 10000
    return hx[old][now]

n = int(input())
hx = [[0] * (n+1) for i in range(n+1)]
print(dfs(n, n))
print(hx)

# 这种超时，只能得50%的分数
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 10 9
Example 2:
9 4
1 2 8 5 7 6 3 9 4
8 7 9 4