python 蓝桥杯2021 模拟 训练

填空题
第一题、ASCII码转换
问题描述
ASCII 码将每个字符对应到一个数值（编码），用于信息的表示和传输。在 ASCII 码中，英文字母是按从小到大的顺序依次编码的，例如：字母 A 编码是 65, 字母 B 编码是 66，字母 C 编码是 67，请问字母 Q 编码是多少？

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

# 1 ascii码转换
# print(ord("Q"))

2 两数互质

# 2 两数互质
# def gcd(i,j):
#     if i < j:
#         i,j=j,i
#     a = 1
#     while a :
#         a = i%j
#         i = j
#         j = a
#     return i

# # print(gcd(12,16))
# sum = 0
# for i in range(1,2020):
#     a = gcd(i,2020)
#     if a==1:
#         sum += 1
# print(sum)

3

第三题、求二叉树叶节点
问题描述
有一棵二叉树，一个由2021个结点，其中有1000个结点有两个子结点，其他的结点有一个或者0个子结点。
请问，这棵二叉树有多少个叶结点？

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

这道题俺直接口算的，根据二叉树的性质就可以

4

第四题、序列长度（取余次数）
问题描述
对于整数 v 和 p，定义 Pierce 序列为：
　　a[1] = v
　　a[i] = p % a[i-1]
　　例如，当 v = 8, p = 21 时，对应的 Pierce 序列为
　　a[1] = 8
　　a[2] = 5
　　a[3] = 1
　　再往后计算，值变为 0，不在我们考虑的范围内。因此当 v = 8, p = 21 时， Pierce 序列的长度为 3。
　　当 p 一定时，对于不同的 v 值，Pierce 序列的长度可能不同。当 p = 8 时，若 1<=v<p，最长的 Pierce 序列出现在 v=13时，为(13, 8, 5, 1)，长度为 4。
　　当 p=2021 时，最长的 Pierce 序列出现在 v=1160 时，请问这个序列有多长？

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

# 4# 最长序列
# a = [0,1160]
# p = 2021
# for i in range(2,1000):
#     x = p % a[i-1]
#     if x == 0:
#         break
#     else :
#         a.append(x)
# print(len(a)-1)

5

第五题、进制转换（10进制转26进制）
问题描述
在 Excel 中，第 1 列到第 26 列的列名依次为 A 到 Z，从第 27 列开始，列名有两个字母组成，第 27 列到第 702 列的列名依次为 AA 到 ZZ。之后的列再用 3 个字母、4 个字母表示。
请问，第 2021 列的列名是什么？

答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个有大写字母组成的字符串，在提交答案时只填写这个字符串，填写多余的内容将无法得分
（思路偏歪，仅做参考，考虑进制10-26的转化是正确的额）

# 5 进制转换
# n = 2021-702

# al = [0,'A','B','C','D''E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

# # 首字母
# if n % 676 == 0:
#     z = n//676
# else :
#     z = n//676 +1
# print(al[z])

# #第2个字母
# ne = 2021 - z*676 -26
# print(ne)

# if ne % 26 == 0:
#     i = ne//26
# else :
#     i = ne//26 +1
# print(al[i])
# # print(i)

# new = 2021 -z*676 - i*26
# j = new

# print(al[z]+al[i]+al[j])



# for i in range(1,27):
#     for j in range(1,27):
#         if i*j == n:
#             print("qq")
#             print("b"+al[i]+al[j])

6

编程题5题
第六题、判断斐波那契数列奇偶性
问题描述
斐波那契数列是这样一个数列：它的第一项和第二项都是1，
从第三项开始每一项都是前两项的和。
根据以上定义，我们容易计算出斐波那契数列的前几项依次是：1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ……
现在请你计算斐波那契数列第N项是奇数还是偶数？

输入格式
输入的包含一个整数N。

输出格式
如果是奇数输出1，是偶数输出0。

样例输入
10

样例输出
1

评测用例规模与约定
对于所有评测用例，1 <= N <= 1000000000。
 

# # 6 判断斐波那契数列奇偶性
# def generate(n):
#     for i in range(3,n+1):
#         x = a[i-1]+a[i-2]
#         a.append(x)

# n = int(input())
# a = [0,1,1]
# if (len(a)-1) < n :
#     generate(n)
# # print(a[n])
# if a[n]%2 == 0:
#     print(0)
# else :
#     print(1)

7

第七题、分割字符串
问题描述
在书写一个较大的整数时，为了方便看清数位，通常会在数位之间加上逗号来分割数位，具体的，从右向左，每三位分成一段，相邻的段之间加一个逗号。
　　例如，1234567 写成 1,234,567。
　　例如，17179869184 写成 17,179,869,184。
　　给定一个整数，请将这个整数增加分割符后输出。

输入格式
输入一行包含一个整数 v。

输出格式
输出增加分割符后的整数。

样例输入
1234567

样例输出
1,234,567

样例输入
17179869184

样例输出
17,179,869,184

数据规模和约定
对于 50% 的评测用例，0 <= v < 10^9 (10的9次方)。
　　对于所有评测用例，0 <= v < 10^18 (10的18次方)。
 

# 7字符串分割
# n = list(input())
# n.reverse()
# a = len(n)%3
# b = (len(n)-a)//3
# # appened ","
# for i in range(1,b+1):
#     n.insert(i*3+(i-1),",")
# n.reverse()
# # delete the first ","
# if n[0] == "," :
#     n.pop(0)
# s =str()
# # list transform string
# for i in n:
#     s = s+i
# print(s+"。")

8

第八题、二维矩阵
问题描述
给定一张图片，由 n 行 m 列像素组成，每个像素由一个范围在 0 到 255 的整数表示。
　　例如，下面是一张 4 行 7 列的图片。
　　8 232 229 23 21 10 247
　　25 252 238 17 241 9 245
　　1 243 251 32 236 31 253
　　13 5 255 8 13 24 11
　　对于每个像素，请找出以这个像素为中心的3行3列中最亮（数值最大）的像素值。
　　
　　例如，第 2 行第 2 列像素值为 252，而它周围 8 个像素都没有它亮，因此第 2 行第 2 列对应的值为 252。
　　第 3 行第 2 列对应的值为255。
　　第 1 行第 1 列为中心不足 3 行 3 列，最大值为 252。
　　将每个像素对应的值写成上面图片的样子，得到：
　　252 252 252 241 241 247 247
　　252 252 252 251 241 253 253
　　252 255 255 255 241 253 253
　　243 255 255 255 236 253 253

输入格式
输入第一行包含两个整数 n, m，分别表示图片的行数和列数。
接下来 n 行，每行 m 个整数，表示一个像素。

输出格式
输出 n 行，每行 m 个整数，表示以每个像素为中心的3行3列中最亮的像素值。

样例输入
4 7
8 232 229 23 21 10 247
25 252 238 17 241 9 245
1 243 251 32 236 31 253
13 5 255 8 13 24 11

样例输出
252 252 252 241 241 247 247
252 252 252 251 241 253 253
252 255 255 255 241 253 253
243 255 255 255 236 253 253

数据规模和约定
对于所有评测用例，图片的行数和列数均不超过 100，每个像素的值为 0 到 255 之间的整数。
（我觉得可以换一种思路，在矩阵四周添一圈0，让每个元素都可以满足三行三列的中心位置，就不用了跟我一样有这么多的判断条件，繁琐还容易出错！）

# # 8 二维矩阵
# old=[]
# n,m = map(int,input().split())
# # print(n,m)
# for i in range(n):
#     d = list(map(int,input().split()))
#     old.append(d)

# 计算每一个中心所在范围的最大值
# def generatemax(i,j):
#     # print(i,j)
#     s =[0]
#     if i-1 < 0:
#         a = 0
#     else :
#         a = i-1

#     if (i+1) > (n-1) :
#         b = n-1
#     else :
#         b = i+1
    
#     if j-1 < 0 :
#         x = 0
#     else:
#         x = j-1

#     if (j+1) > (m-1) :
#         y = m-1
#     else:
#         y = j+1

#     for f in range(a,b+1):
#         s.extend(old[f][x:y+1])
#     shu = max(s)
#     # print(shu)
#     return shu


# # 主函数
# new = list()
# for i in range(n):
#     inner = list()
#     for j in range(m):
#         a = generatemax(i,j)
#         inner.append(a)
#     new.append(inner)
# # 按格式打印输出
# for i in new:
#     for j in i:
#         print(j,end=" ")
#     print()

不对之处，请指正，感谢！