第十五届蓝桥杯（2023）模拟赛第二期python_蓝桥杯第15届pythonb组神奇闹钟

目录

第一题 填空题

第二题 填空题

第三题 填空题

第四题 填空题

第五题 填空题

 

第六题 编程题

第七题 编程题

 第八题 编程题

第九题 编程题

 第十题 编程题

---

 

5道填空题，5道编程题。本文代码使用python语言编写。

第一题 填空题

一、问题描述

小蓝要在屏幕上放置一行文字，每个字的宽度相同。 小蓝发现，如果每个字的宽为 36 像素，一行正好放下 30 个字，字符之间和前后都没有任何空隙。 请问，如果每个字宽为 10 像素，字符之间不包含空隙，一行可以放下多少个字？

 

答案提交

 

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

 代码：

print(30 * 36 // 10)

 答案：108

第二题 填空题

二、问题描述

求 2**2023%1000，即 2 的 2023 次方除以 1000 的余数。

 

答案提交

 

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

 代码：

print(2 ** 2023 % 1000)

答案：608 

第三题 填空题

 

三、问题描述

如果一个正整数转化成二进制与转换成八进制后所有数位的数字之和相等，则称为数位和相等的数。 前几个数位和相等的正整数为 1, 8, 9, 64, …… 请问第 23 个数位和相等的正整数是多少？

 

答案提交

 

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

代码：

s = 0
n = 1
while True:
    a = sum(int(i) for i in bin(n)[2:])
    b = sum(int(i) for i in oct(n)[2:])
    if a == b:
        s += 1
        if s == 23:
            break
    n += 1
 
print(n)

答案：4169

while True无限循环，直到找到符合条件的数再执行break跳出循环。

第四题 填空题

四、问题描述

对于以下这些数（6 行，每行 6 个，共 36 个），请问约数个数最多的是哪个？（如果有多个，请回答出现最早的那个）

393353 901440 123481 850930 423154 240461

373746 232926 396677 486579 744860 468782

941389 777714 992588 343292 385198 876426

483857 241899 544851 647930 772403 109929

882745 372491 877710 340000 659788 658675

296521 491295 609764 718967 842000 670302

 

答案提交

 

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

代码：

def count_yueshu(num):
    s = 0
    for i in range(1,num+1):
        if num % i ==0:
            s += 1
    return s
 
nums = [
    [393353, 901440, 123481, 850930, 423154, 240461],
    [373746, 232926, 396677, 486579, 744860, 468782],
    [941389, 777714, 992588, 343292, 385198, 876426],
    [483857, 241899, 544851, 647930, 772403, 109929],
    [882745, 372491, 877710, 340000, 659788, 658675],
    [296521, 491295, 609764, 718967, 842000, 670302]
]
 
count = 0
num = None
 
for row in nums:
    for a in row:
        di_count = count_yueshu(a)
        if di_count > count:
            count = di_count
            num = a
                
print(num)

 答案：901440

第五题 填空题

五、问题描述

小蓝有一个 01 矩阵。他打算将第一行第一列的 0 变为 2 。变化过程有传染性，每次 2 的上下左右四个相邻的位置中的 0 都会变成 2 。直到最后每个 2 的周围都是 1 或 2 结束。

请问，最终矩阵中有多少个 2 ？

 

以下是小蓝的矩阵，共 30 行 40 列。

0000100010000001101010101001001100000011

0101111001111101110111100000101010011111

1000010000011101010110000000001011010100

0110101010110000000101100100000101001001

0000011010100000111111001101100010101001

0110000110000000110100000000010010100011

0100110010000110000000100010000101110000

0010011010100110001111001101100110100010

1111000111101000001110010001001011101101

0011110100011000000001101001101110100001

0000000101011000010011111001010011011100

0000100000011001000100101000111011101100

0010110000001000001010100011000010100011

0110110000100011011010011010001101011011

0000100100000001010000101100000000000010

0011001000001000000010011001100101000110

1110101000011000000100011001001100111010

0000100100111000001101001000001010010001

0100010010000110100001100000110111110101

1000001001100010011001111101011001110001

0000000010100101000000111100110010101101

0010110101001100000100000010000010110011

0000011101001001000111011000100111010100

0010001100100000011000101011000000010101

1001111010010110011010101110000000101110

0110011101000010100001000101001001100010

1101000000010010011001000100110010000101

1001100010100010000100000101111111111100

1001011010101100001000000011000110110000

0011000100011000010111101000101110110001

 

答案提交

 

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

 

代码：

def dfs(nums, a, b, rows, cols): #  (矩阵，行索引，列索引，行数，列数)
    if a < 0 or a >= rows or b < 0 or b >= cols or nums[a][b] != 0:
        return
 
    nums[a][b] = 2
 
    dfs(nums, a - 1, b, rows, cols)
    dfs(nums, a + 1, b, rows, cols)
    dfs(nums, a, b - 1, rows, cols)
    dfs(nums, a, b + 1, rows, cols)
 
def count_2(nums):
    rows = len(nums)
    cols = len(nums[0])
 
    dfs(nums, 0, 0, rows, cols)
 
    count = sum(row.count(2) for row in nums)
    return count
 
 
nums = [
    [0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,1,0,0,0,0,0,0,1,1],
    [0,1,0,1,1,1,1,0,0,1,1,1,1,1,0,1,1,1,0,1,1,1,1,0,0,0,0,0,1,0,1,0,1,0,0,1,1,1,1,1],
    [1,0,0,0,0,1,0,0,0,0,0,1,1,1,0,1,0,1,0,1,1,0,0,0,0,0,0,0,0,0,1,0,1,1,0,1,0,1,0,0],
    [0,1,1,0,1,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,1,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,1],
    [0,0,0,0,0,1,1,0,1,0,1,0,0,0,0,0,1,1,1,1,1,1,0,0,1,1,0,1,1,0,0,0,1,0,1,0,1,0,0,1],
    [0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,0,0,1,1],
    [0,1,0,0,1,1,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,1,1,1,0,0,0,0],
    [0,0,1,0,0,1,1,0,1,0,1,0,0,1,1,0,0,0,1,1,1,1,0,0,1,1,0,1,1,0,0,1,1,0,1,0,0,0,1,0],
    [1,1,1,1,0,0,0,1,1,1,1,0,1,0,0,0,0,0,1,1,1,0,0,1,0,0,0,1,0,0,1,0,1,1,1,0,1,1,0,1],
    [0,0,1,1,1,1,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,0,1,1,1,0,1,0,0,0,0,1],
    [0,0,0,0,0,0,0,1,0,1,0,1,1,0,0,0,0,1,0,0,1,1,1,1,1,0,0,1,0,1,0,0,1,1,0,1,1,1,0,0],
    [0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,1,1,1,0,1,1,0,0],
    [0,0,1,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,0,1,0,0,0,1,1,0,0,0,0,1,0,1,0,0,0,1,1],
    [0,1,1,0,1,1,0,0,0,0,1,0,0,0,1,1,0,1,1,0,1,0,0,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,1,1],
    [0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
    [0,0,1,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,1,0,0,1,0,1,0,0,0,1,1,0],
    [1,1,1,0,1,0,1,0,0,0,0,1,1,0,0,0,0,0,0,1,0,0,0,1,1,0,0,1,0,0,1,1,0,0,1,1,1,0,1,0],
    [0,0,0,0,1,0,0,1,0,0,1,1,1,0,0,0,0,0,1,1,0,1,0,0,1,0,0,0,0,0,1,0,1,0,0,1,0,0,0,1],
    [0,1,0,0,0,1,0,0,1,0,0,0,0,1,1,0,1,0,0,0,0,1,1,0,0,0,0,0,1,1,0,1,1,1,1,1,0,1,0,1],
    [1,0,0,0,0,0,1,0,0,1,1,0,0,0,1,0,0,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,0,1,1,1,0,0,0,1],
    [0,0,0,0,0,0,0,0,1,0,1,0,0,1,0,1,0,0,0,0,0,0,1,1,1,1,0,0,1,1,0,0,1,0,1,0,1,1,0,1],
    [0,0,1,0,1,1,0,1,0,1,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,1,1,0,0,1,1],
    [0,0,0,0,0,1,1,1,0,1,0,0,1,0,0,1,0,0,0,1,1,1,0,1,1,0,0,0,1,0,0,1,1,1,0,1,0,1,0,0],
    [0,0,1,0,0,0,1,1,0,0,1,0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,1,0,1,0,1],
    [1,0,0,1,1,1,1,0,1,0,0,1,0,1,1,0,0,1,1,0,1,0,1,0,1,1,1,0,0,0,0,0,0,0,1,0,1,1,1,0],
    [0,1,1,0,0,1,1,1,0,1,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,1,0,0,1,0,0,1,1,0,0,0,1,0],
    [1,1,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,1,1,0,0,1,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,1,0,1],
    [1,0,0,1,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0],
    [1,0,0,1,0,1,1,0,1,0,1,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,1,0,0,0,0],
    [0,0,1,1,0,0,0,1,0,0,0,1,1,0,0,0,0,1,0,1,1,1,1,0,1,0,0,0,1,0,1,1,1,0,1,1,0,0,0,1]
]
 
print(count_2(nums))

答案：541 

深度优先搜索（DFS），定义名为dfs的函数，此函数接受一个矩阵、当前位置的行索引、列索引、矩阵的行数和列数作为参数。如果当前位置不是0，或者已经被访问过，函数直接返回。否则，将当前位置的值设为2，并递归地访问上下左右四个相邻位置。

然后定义了一个名为count_2的函数，此函数接受一个矩阵作为参数。函数首先获取矩阵的行数和列数，然后将第一行第一列的0变为2，开始进行深度优先搜索。最后，统计最终矩阵中值为2的元素的个数，并返回这个数量。

第六题 编程题

六、问题描述

给定一个正好六位的正整数 x，请将 x 循环左移一位后输出。 所谓循环左移一位，是指将原来的十万位变为个位，原来的万位到个位向左移动依次变为十万位到十位。

 

例如：194910 左移一位变为 949101 。

又如：987123 左移一位变为 871239 。

 

输入格式

输入一行包含一个整数 x 。保证输入的 x 正好包含 6 个十进制数位，而且十万位和万位上的数字均不为 0 。

 

输出格式

输出一行包含一个整数，表示答案。

 

样例输入

194910

样例输出

949101

代码：

num = str(input())
a = num[0]
b = num[1:]
c = int(b+a)
print(c)

使用两个切片提取元素，然后赋值给c并打印输出。 

第七题 编程题

七.问题描述

输入一个仅包含小写英文字母的字符串，请问这个字符串中的最后一元音是什么。

在英文中，a, e, i, o, u 共 5 个字母是元音字母，其它字母不是元音字母。

 

输入格式

输入一行包含一个字符串，仅由小写英文字符组成，字符串中至少包含一个元音字母。

 

输出格式

输出一行包含一个字符，表示答案。

 

样例输入

lanqiao

样例输出

o

 

样例输入

cup

样例输出

u

评测用例规模与约定对于所有评测用例，1 <= 字符数量 <= 10000 。 

代码：

n = str(input())
a = 'aeiou'
n = reversed(n)
for i in n:
    if i in a:
        break
print(i)

 第八题 编程题

八.问题描述

给定一个整数，对这个整数的一次转换是指将这个整数变为这个整数的所有数位上的非零数字的乘积。

 

例如，对 123456789 进行一次转换变为 123456789=362880，再进行一次转换变为 36288=2304，再进行一次转换变为 234=24，再进行一次转换变为 8。 给定一个整数，请依次将转换过程中经历的每个整数输出，直到小于 10 。

 

输入格式

输入一行包含一个整数 n 。

 

输出格式

输出多行，每行包含一个整数。

 

样例输入

123456789

样例输出

362880

2304

24

8

 

评测用例规模与约定

对于 50% 的评测用例，1 <= n <= 10**9 （10 的 9 次方）。

对于所有评测用例，1 <= n <= 10**18 （10 的 18 次方）。

代码：

def convert(num):
    p = 1
    for i in str(num):
        if i != '0':
            p *= int(i)
    return p
 
num = int(input())
while num > 9:
    num = convert(num)
    print(num)

while循环，当整数num大于9时，继续转换。

第九题 编程题

九.问题描述

 

小蓝站在一个 n 行 m 列的方格图中间，方格图的每一个方格上都标有一个正整数。

如果两个相邻方格（上下左右四个方向相邻）内的数的最大公约数大于 1 ，则可以从其中一个方格移动到另一个方格，当然也可以从另一个方格移回第一个方格。

假设小蓝开始时站在第 r 行第 c 列，请问小蓝可以移动到方格图内的多少个方格？

 

输入格式

输入的第一行包含两个整数 n, m ，用一个空格分隔，表示方格图的行数和列数。

接下来 n 行，每行包含 m 个正整数，相邻整数间用一个空格分隔，依次表示方格图中从第 1 行到第 n 行，每行从第 1 列到第 m 列中的数。

接下来一行包含两个整数 r, c，用一个空格分隔，表示小蓝所在的行号和列号。

 

输出格式

输出一行包含一个整数，表示答案。

 

样例输入

3 4

3 6 5 5

2 4 3 5

7 8 3 8

3 2

样例输出

5

 

评测用例规模与约定

对于 50%的评测用例，1 <= n, m <= 100，方格图中的每个数不超过 10**5 （10 的 5次方）。

对于所有评测用例，1 <= n, m <= 1000，方格图中的每个数不超过 10**9 （10 的 9 次方）。

这题当时没有写出来，只写了输入数据的几行代码

代码：

import math
 
def count_accessible_cells(grid, r, c):
    # 获取方格图的行数和列数
    n, m = len(grid), len(grid[0])
 
    # 判断两个方格是否可以互相到达
    def can_reach(x1, y1, x2, y2):
        return 0 <= x1 < n and 0 <= y1 < m and 0 <= x2 < n and 0 <= y2 < m and math.gcd(grid[x1][y1], grid[x2][y2]) > 1
 
    # 初始化访问数组，表示方格是否被访问过
    visited = [[False] * m for _ in range(n)]
 
    # 深度优先搜索，统计可到达的方格数量
    def dfs(x, y):
        if x < 0 or x >= n or y < 0 or y >= m or visited[x][y]:
            return 0
 
        visited[x][y] = True
        count = 1
 
        # 检查上下左右四个方向
        directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        for dx, dy in directions:
            new_x, new_y = x + dx, y + dy
            if can_reach(x, y, new_x, new_y):
                count += dfs(new_x, new_y)
 
        return count
 
    # 调用深度优先搜索函数，并返回结果
    return dfs(r - 1, c - 1)
 
# 读取输入
n, m = map(int, input().split())
grid = [list(map(int, input().split())) for i in range(n)]
r, c = map(int, input().split())
 
# 调用函数计算可到达的方格数量，并输出结果
result = count_accessible_cells(grid, r, c)
print(result)

 第十题 编程题

十.问题描述

给定一个序列 a[1], a[2], …, a[n] 和一个整数 k，请找出一个长度正好为 k 的区间，使得区间中所有数的和最大。

即要找到一个整数 p ，使得 1 <= p 且 p+k-1 <= n ，使得 a[p]+a[p+1]+...+a[p+k-1] 最大。

 

输入格式

输入的第一行包含两个整数 n , k。

第二行包含 n 个整数，相邻的整数之间使用一个空格分隔，表示给定的序列。

 

输出格式

输出一行包含一个整数，表示最大的区间和，你只需要输出和就行，不需要输出方案。

 

样例输入

6 3

2 3 9 1 9 5

样例输出

19

 

评测用例规模与约定

对于 30% 的评测用例，1 <= k <= n <= 30，1 <= a[i] <= 100。

对于 60% 的评测用例，1 <= k <= n <= 1000，1 <= a[i] <= 10000。

对于所有评测用例，1 <= k <= n <= 100000，1 <= a[i] <= 1000000。

代码：

def sum(n, k, nums):
    # 计算前缀和
    prefix_sum = [0] * (n + 1)
    for i in range(1, n + 1):
        prefix_sum[i] = prefix_sum[i - 1] + nums[i - 1]
 
    max_sum = float('-inf')
 
    # 遍历所有可能的区间
    for i in range(n - k + 1):
        current_sum = prefix_sum[i + k] - prefix_sum[i]
        max_sum = max(max_sum, current_sum)
 
    return max_sum
 
# 读取输入
n, k = map(int, input().split())
nums = list(map(int, input().split()))
 
# 调用函数计算最大区间和，并输出结果
result = sum(n, k, nums)
print(result)

有问题欢迎指正。