当前位置:   article > 正文

第十四届蓝桥杯模拟赛 大学B组 Python_14届蓝桥杯b组第一题题解

14届蓝桥杯b组第一题题解

前言

第十四届蓝桥杯模拟赛(第三期)Python

第一题

第一题如下

  填空题
  请找到一个大于 2022 的最小数,这个数转换成十六进制之后,所有的数位(不含前导 0)都为字母(A 到 F)。
  
 请将这个数的十进制形式作为答案提交。
  • 1
  • 2
  • 3
  • 4

刚开始没看懂什么意思,先使用下方语句得到2022的十六进制是0x7E6,难么比它大的数且不含数字的16进制数为AAA,将答案2730填入空中即可

print(hex(2022))
print(int(0xAAA))
  • 1
  • 2

第二题

	填空题
	在 Excel 中,列的名称使用英文字母的组合。
	前 26 列用一个字母,依次为 A 到 Z,接下来 26*26 列使用两个字母的组合,依次为 AA 到 ZZ。
	
  请问第 2022 列的名称是什么?
  • 1
  • 2
  • 3
  • 4
  • 5

解法1:这题很浅显了,其实就是计算出2022的27进制是多少?填空题不考虑时间复杂度了,直接使用暴力算法。结果是BYT

for i in range(26):
    for j in range(26):
        for k in range(26):
            if 26*26*i + 26*j + k == 2022:
                s = chr(i+96) + chr(j+96) + chr(k+96)
                break

print(s.upper())
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

解法2:它已经告诉我们用的是excel了,那我们就听它的用excel来做吧!毕竟填空题讲究的就是不择手段。

需要值得注意的是我用的xls格式的只能拖动到256列,而xlsx格式的表格似乎可以拖动到∞行。

BYRBYSBYT
202020212022

第三题

	对于一个日期,我们可以计算出年份的各个数位上的数字之和,也可以分别计算月和日的各位数字之和。
	
	请问从 1900 年 1 月 1 日至 9999 年 12 月 31 日,总共有多少天,年份的数位数字之和等于月的数位数字之和加日的数位数字之和。
	
  例如,2022年11月13日满足要求,因为 2+0+2+2=(1+1)+(1+3) 。
  请提交满足条件的日期的总数量。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

看到诸如此类的日期题,立刻想到的是python的datetime库,它属于python内置的库,并不属于第三方库,我们在算法比赛中是可以调用的。

最后算出来的结果是70910,使用到的算法比较暴力,需要等大搞一分钟程序才会计算出最终结果,填空题就不纠结这么多了。

import datetime

def check(time):
    year, month, day = time.split('-')
    num1, num2, num3 = 0, 0, 0
    for i in year:
        num1 += int(i)
    for i in month:
        num2 += int(i)
    for i in day:
        num3 += int(i)
    if num1 == num2 + num3:
        return True
    else:
        return False

num = 0
start = datetime.date(1900, 1, 1)
end = datetime.date(9999, 12, 31)

while start <= end:
    if check(str(start)):
        num += 1
    if start == end:
        break
    start += datetime.timedelta(days=1)

print(num) # 答案是70910
  • 1
  • 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

第四题

	小蓝有 30 个数,分别为:99, 22, 51, 63, 72, 61, 20, 88, 40, 21, 63, 30, 11, 18, 99, 12, 93, 16, 7, 53, 64, 9, 28, 84, 34, 96, 52, 82, 51, 77 。
  小蓝可以在这些数中取出两个序号不同的数,共有 30*29/2=435 种取法。
  
  请问这 435 种取法中,有多少种取法取出的两个数的乘积大于等于 2022 。
  • 1
  • 2
  • 3
  • 4

就是用一个两层循环使得数字两两之间相乘就可以了,需要注意的是要排除自己乘自己的情况。

答案是189

ans = 0
li = [99, 22, 51, 63, 72, 61, 20, 88, 40, 21, 63, 30, 11, 18, 99, 12, 93, 16, 7, 53, 64, 9, 28, 84, 34, 96, 52, 82, 51, 77]
for i in range(len(li)):
    for j in range(len(li)):
        # 此处if语句的目的是排除 自己乘自己 的情况
        if i == j:
            continue
        else:
            if li[i]*li[j] >= 2022:
                print(li[i]*li[j])
                ans += 1

print(ans)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

第五题

填空题
问题描述
  小蓝有一个 30 行 60 列的数字矩阵,矩阵中的每个数都是 0 或 1 。
  110010000011111110101001001001101010111011011011101001111110
  010000000001010001101100000010010110001111100010101100011110
  001011101000100011111111111010000010010101010111001000010100
  101100001101011101101011011001000110111111010000000110110000
  010101100100010000111000100111100110001110111101010011001011
  010011011010011110111101111001001001010111110001101000100011
  101001011000110100001101011000000110110110100100110111101011
  101111000000101000111001100010110000100110001001000101011001
  001110111010001011110000001111100001010101001110011010101110
  001010101000110001011111001010111111100110000011011111101010
  011111100011001110100101001011110011000101011000100111001011
  011010001101011110011011111010111110010100101000110111010110
  001110000111100100101110001011101010001100010111110111011011
  111100001000001100010110101100111001001111100100110000001101
  001110010000000111011110000011000010101000111000000110101101
  100100011101011111001101001010011111110010111101000010000111
  110010100110101100001101111101010011000110101100000110001010
  110101101100001110000100010001001010100010110100100001000011
  100100000100001101010101001101000101101000000101111110001010
  101101011010101000111110110000110100000010011111111100110010
  101111000100000100011000010001011111001010010001010110001010
  001010001110101010000100010011101001010101101101010111100101
  001111110000101100010111111100000100101010000001011101100001
  101011110010000010010110000100001010011111100011011000110010
  011110010100011101100101111101000001011100001011010001110011
  000101000101000010010010110111000010101111001101100110011100
  100011100110011111000110011001111100001110110111001001000111
  111011000110001000110111011001011110010010010110101000011111
  011110011110110110011011001011010000100100101010110000010011
  010011110011100101010101111010001001001111101111101110011101
  如果从一个标为 1 的位置可以通过上下左右走到另一个标为 1 的位置,则称两个位置连通。
   与某一个标为 1 的位置连通的所有位置(包括自己)组成一个连通分块。
  请问矩阵中最大的连通分块有多大?
  
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
  • 1
  • 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
  • 38

使用dfs(深度优先搜索算法),最终答案是148

def dfs(x, y):
    global cur, vis
    for i, j in [[0, 1], [1, 0], [-1, 0], [0, -1]]:
        dx = i + x
        dy = j + y
        if dx < 0 or dy < 0 or dx >= 30 or dy >= 60 or mp[dx][dy] == '0' or vis[dx][dy]:
            continue
        cur += 1
        vis[dx][dy] = 1
        dfs(dx, dy)


n, m = 30, 60
mp = []
for _ in range(n):
    mp.append(input())

vis = [[0] * m for _ in range(n)]
ans, cur = 0, 0

for i in range(n):
    for j in range(m):
        if mp[i][j] == '0':
            continue
        vis = [[0] * m for _ in range(n)]
        vis[i][j] = 1
        cur = 1
        dfs(i, j)
        ans = max(ans, cur)

print(ans)
  • 1
  • 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

第六题

  给定一天是一周中的哪天,请问 n 天后是一周中的哪天?
输入格式
  输入第一行包含一个整数 w,表示给定的天是一周中的哪天,w 为 1 到 6 分别表示周一到周六,w 为 7 表示周日。
  第二行包含一个整数 n。
输出格式
  输出一行包含一个整数,表示 n 天后是一周中的哪天,1 到 6 分别表示周一到周六,7 表示周日。
  
样例输入
6
10
样例输出
2
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

这个题目就是让你输入周x,算出y天后是周z

需要注意的是如果周三的4天之后是周日,会被7整除,结果会变成0,其实是周日,答案应该是7,所以我们添加一个if语句进行判断。

a = int(input()) # 今天是周x?
b = int(input()) # y天之后?

ans = (a+b)%7

if ans == 0:
    ans = 7

# if语句也可以使用这种写法
# ans = ans if ans == 0 else 7
    
print(ans) # 周x的y天之后是周z
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

第七题

  小蓝负责一块区域的信号塔安装,整块区域是一个长方形区域,建立坐标轴后,西南角坐标为 (0, 0), 东南角坐标为 (W, 0), 西北角坐标为 (0, H), 东北角坐标为 (W, H)。其中 W, H 都是整数。
  他在 n 个位置设置了信号塔,每个信号塔可以覆盖以自己为圆心,半径为 R 的圆形(包括边缘)。
  为了对信号覆盖的情况进行检查,小蓝打算在区域内的所有横纵坐标为整数的点进行测试,检查信号状态。其中横坐标范围为 0 到 W,纵坐标范围为 0 到 H,总共测试 (W+1) * (H+1) 个点。
  
  给定信号塔的位置,请问这 (W+1)*(H+1) 个点中有多少个点被信号覆盖。
  
输入格式
  输入第一行包含四个整数 W, H, n, R,相邻整数之间使用一个空格分隔。
  接下来 n 行,每行包含两个整数 x, y,表示一个信号塔的坐标。信号塔可能重合,表示两个信号发射器装在了同一个位置。
输出格式
  输出一行包含一个整数,表示答案。

样例输入
10 10 2 5
0 0
7 0
样例输出
57

评测用例规模与约定
  对于所有评测用例,1 <= W, H <= 100,1 <= n <= 100, 1 <= R <= 100, 0 <= x <= W, 0 <= y <= H。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

题目看起来很难,其实就是先构造一个大小为(W+1)*(H+1)的二维数组,然后在指定坐标放入n个信号塔,信号塔的信号范围是R,求数组中有多少个点信号被覆盖.

模拟的时候并没有做出来,如果有更好的办法或思路欢迎下方留言。

def check(x, y):
    for i in range(n):
        if (x - point[i][0]) ** 2 + (y - point[i][1]) ** 2 <= r * r:
            return True
    return False


w, h, n, r = map(int, input().split())
point = []
for _ in range(n):
    row = list(map(int, input().split()))
    point.append(row)

ans = 0
for i in range(w + 1):
    for j in range(h + 1):
        if check(i, j):
            ans += 1
            
print(ans)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

第八题

  小蓝有一个 n * m 大小的矩形水域,小蓝将这个水域划分为 n 行 m 列,行数从 1 到 n 标号,列数从 1 到 m 标号。每行和每列的宽度都是单位 1 。
  现在,这个水域长满了水草,小蓝要清理水草。
  每次,小蓝可以清理一块矩形的区域,从第 r1 行(含)到第 r2 行(含)的第 c1 列(含)到 c2 列(含)。
  
  经过一段时间清理后,请问还有多少地方没有被清理过。
  
输入格式
  输入第一行包含两个整数 n, m,用一个空格分隔。
  第二行包含一个整数 t ,表示清理的次数。
  接下来 t 行,每行四个整数 r1, c1, r2, c2,相邻整数之间用一个空格分隔,表示一次清理。请注意输入的顺序。
输出格式
  输出一行包含一个整数,表示没有被清理过的面积。
  
样例输入
2 3
2
1 1 1 3
1 2 2 2
样例输出
2
样例输入
30 20
2
5 5 10 15
6 7 15 9
样例输出
519
评测用例规模与约定
  对于所有评测用例,1 <= r1 <= r2 <= n <= 100, 1 <= c1 <= c2 <= m <= 100, 0 <= t <= 100。
  • 1
  • 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

题目的意思是小蓝要去清理n*m大小的水池,清理t次,每一次清理都会把(r1,c1)-(r2,c2)区域内的杂草给清理。

这题和上一题类似,都是需要将二维数组中的t个指定区域遍历一遍。

答案代码如下:

n,m = map(int,input().split(sep = " "))

t = int(input())
rules = []

for i in range(t):
    rule = list(map(int,input().split(sep = " ")))
    rules.append(rule)
    
# import time
# ti = time.localtime()

sq = []
for i in range(n):
    li = [0]*m
    sq.append(li)

# print("清理前------")
# for i in sq:
#     print(i)

for rule in rules:
    for i in range(rule[0]-1,rule[2]):
        for j in range(rule[1]-1,rule[3]):
            sq[i][j] = 1

# print("清理后------")
# for i in sq:
#     print(i)

ans = n*m
for i in sq:
    for j in i:
        if j == 1:
            ans -= 1

# print("答案------")
print(ans)


# print(ti.tm_sec-time.localtime().tm_sec)
  • 1
  • 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
  • 38
  • 39
  • 40
  • 41

思考过这中暴力算法能不能在规定时间(2s)内算出正确答案,于是我自己创建了一组实验数据,可以把我的代码中的下面三句注释语句加入执行,然后使用下方我的最大测试数据来测试,发现时间能够在1s内完成运算,远超题目要求

# import time
# ti = time.localtime()
# print(ti.tm_sec-time.localtime().tm_sec)
  • 1
  • 2
  • 3

测试数据:

"""
100 100
100
1 1 98 25
1 1 41 31
1 1 38 26
1 1 94 36
1 1 50 3
1 1 13 68
1 1 18 82
1 1 1 77
1 1 43 72
1 1 83 74
1 1 100 52
1 1 23 37
1 1 21 43
1 1 77 8
1 1 35 30
1 1 4 74
1 1 89 40
1 1 68 2
1 1 97 46
1 1 42 44
1 1 25 4
1 1 77 6
1 1 29 10
1 1 90 15
1 1 2 41
1 1 61 86
1 1 66 65
1 1 36 91
1 1 51 27
1 1 17 33
1 1 60 96
1 1 74 85
1 1 17 81
1 1 30 89
1 1 96 27
1 1 22 43
1 1 51 2
1 1 10 29
1 1 63 91
1 1 82 14
1 1 38 92
1 1 56 19
1 1 45 46
1 1 94 58
1 1 13 30
1 1 64 64
1 1 82 28
1 1 58 6
1 1 8 7
1 1 72 44
1 1 52 3
1 1 21 36
1 1 76 49
1 1 90 78
1 1 53 88
1 1 87 96
1 1 49 72
1 1 12 19
1 1 8 90
1 1 68 28
1 1 49 17
1 1 45 19
1 1 86 91
1 1 65 76
1 1 3 49
1 1 97 36
1 1 46 95
1 1 57 94
1 1 75 37
1 1 23 54
1 1 69 79
1 1 81 39
1 1 60 4
1 1 23 37
1 1 79 98
1 1 64 38
1 1 17 94
1 1 76 78
1 1 35 7
1 1 16 33
1 1 94 99
1 1 44 30
1 1 55 1
1 1 17 92
1 1 30 48
1 1 65 96
1 1 86 38
1 1 77 11
1 1 17 71
1 1 88 40
1 1 6 26
1 1 4 16
1 1 29 45
1 1 24 47
1 1 66 81
1 1 99 35
1 1 91 57
1 1 41 60
1 1 27 89
1 1 5 39
"""
  • 1
  • 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
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104

第九题

  小蓝准备在一个空旷的场地里面滑行,这个场地的高度不一,小蓝用一个 n 行 m 列的矩阵来表示场地,矩阵中的数值表示场地的高度。
  如果小蓝在某个位置,而他上、下、左、右中有一个位置的高度(严格)低于当前的高度,小蓝就可以滑过去,滑动距离为 1 。
  如果小蓝在某个位置,而他上、下、左、右中所有位置的高度都大于等于当前的高度,小蓝的滑行就结束了。
  小蓝不能滑出矩阵所表示的场地。
  
  小蓝可以任意选择一个位置开始滑行,请问小蓝最多能滑行多远距离。
  
输入格式
  输入第一行包含两个整数 n, m,用一个空格分隔。
  接下来 n 行,每行包含 m 个整数,相邻整数之间用一个空格分隔,依次表示每个位置的高度。
输出格式
  输出一行包含一个整数,表示答案。
样例输入
4 5
1 4 6 3 1
11 8 7 3 1
9 4 5 2 1
1 3 2 2 1
样例输出
7
样例说明
  滑行的位置一次为 (2, 1), (2, 2), (2, 3), (3, 3), (3, 2), (4, 2), (4, 3)。
评测用例规模与约定
  对于 30% 评测用例,1 <= n <= 20,1 <= m <= 20,0 <= 高度 <= 100。
  对于所有评测用例,1 <= n <= 100,1 <= m <= 100,0 <= 高度 <= 10000。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

这题还没做出来,欢迎评论区交流。

第十题

  小蓝有一个序列 a[1], a[2], ..., a[n]。
  给定一个正整数 k,请问对于每一个 1 到 n 之间的序号 i,a[i-k], a[i-k+1], ..., a[i+k] 这 2k+1 个数中的最小值是多少?当某个下标超过 1 到 n 的范围时,数不存在,求最小值时只取存在的那些值。
  
输入格式
  输入的第一行包含一整数 n。
  第二行包含 n 个整数,分别表示 a[1], a[2], ..., a[n]。
  第三行包含一个整数 k 。
输出格式
  输出一行,包含 n 个整数,分别表示对于每个序号求得的最小值。
样例输入
5
5 2 7 4 3
1
样例输出
2 2 2 3 3

评测用例规模与约定
  对于 30% 的评测用例,1 <= n <= 1000,1 <= a[i] <= 1000。
  对于 50% 的评测用例,1 <= n <= 10000,1 <= a[i] <= 10000。
  对于所有评测用例,1 <= n <= 1000000,1 <= a[i] <= 1000000。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

这题也还还没做出来,欢迎评论区交流。

总结

本次模拟赛的题目偏向简单,正式赛大家切记不可疏忽,正式赛做出1个填空题+3个大题大概就是省赛三等奖的水平,在多做出半个大题大致是省赛二等奖的水平。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/笔触狂放9/article/detail/64229
推荐阅读
相关标签
  

闽ICP备14008679号