更多真题及解析见：24 套真题
截至最新题库，一共是 24 套真题，其中14套有编程题的参考答案。
有参考答案的（共14套真题有参考答案）：
15届省赛，12届、13届、14届的国赛真题，14届的省赛和4次选拔赛、13届的3次选拔赛、12届的2次选拔赛，
无参考答案的（共10套真题）：
15届5次选拔赛（最新是2024年3月10日的真题）、13届省赛、12届省赛、11届省赛和国赛、10届省赛
选择题
1. 运行下面程序，输出的结果是（）。
s = ‘py’
print(‘t’.join(s))
A、tpy
B、pty
C、tpty
D、tptyt
2. 运行下面程序，输出的结果是（）。
x = 1, 2, 3
print(type(x))
A. <- Class ‘tuple’>
B. <- Class ‘int’>
C. <- Class ‘list’>
D. 报错
3. 下列哪个函数可以返回列表中的最大值？（）
A. len()
B. sum()
C. sort()
D. max()
4. 下列哪个运算符可将两个字符串拼接起来？( )
A. *
B. +
C.%
D. //
5. 关于Python函数的描述，错误的是( )。
A. 调用函数时，实参可以是一个表达式
B. 没有return语句的函数执行结束后，返回None
C. 函数形参为*name新式时，*name形参接收一个字典
D. 调用函数时，关键字参数必须在位置参数后面
编程题
1. 偶数
题目描述:
(注.input()输入函数的括号中不允许添加任何信息)
偶数:指能够被 2 整除的整数。例如:2. 4. 6. 8.
给定一个偶数 n，计算 n可以由多少个2相加得到。例如:n=10;10可以由5个2相加得到(2+2+2+2+2)。
输入描述
输入一个偶数n(2≤n≤100)
输出描述
输出一个整数，表示n可以由多少个2相加得到
样例输入
10
样例输出
5
2. 字母比较
题目描述:
(注.input()输入函数的括号中不允许添加任何信息)
给定两个不相同的大写字母，比较它们在英文字母表中的位置，输出位置更靠后的字母。例如:大写字母 D和 H;D和H相比，H在英文字母表中位置更靠后。
输入描述
第一行输入一个大写字母
第二行输入一个大写字母
输出描述
输出位置靠后的字母
样例输入
D
H
样例输出
H
3. 石头运输
题目描述
给定三个整数，表示三块石头的重量。请你在不分割石头的情况下，将三块石头分给两辆车运输，使得两辆车各自运输的石头总重量尽可能相近，并分别输出两辆车运输的石头总重量。
例如：
a. 三块石头的重量分别为 4、2、3；
b. 一辆车运输重量为4的石头；
c. 另一辆车运输重量为2和3的石头；
d. 两辆车运输的石头总重量分别是4和5，各自运输的石头总重量已尽可能相近，所以输出4和5。
输入描述
输入仅一行，包含三个整数（1≤整数≤200），分别表示三块石头的重量，整数之间以一个空格隔开
输出描述
按从小到大的顺序输出两个整数，分别表示两辆车各自运输的石头总重量，整数之间以一个空格隔开
样例输入
4 2 3
样例输出
4 5
4. 连续正整数和
题目描述
(注：input()输入函数的括号中不允许添加任何信息)
给定一个正整数 n，请计算n最多可以由多少个连续(2个及以上)的正整数相加得到，如果n不能由连续的正整数相加得到，则输出-1。
例如:n=100;100 可以由以下2组连续的正整数相加得到。
第一组:9、10、11、12、13、14、15、16;
第二组:18、19、20、21、22;
100 最多可以由 8个连续的正整数相加得到，输出8.
例如：
n=8; 8不能由连续的正整数相加得到，输出-1.
输入描述
输入一个正整数n(3≤n≤108)
输出描述
输出一个整数，表示 n最多可以由多少个连续的正整数相加得到;如果n不能由连续的正整数相加得到，则输出 -1。
样例输入
100
样例输出
8
5. 浇花系统
题目描述
有n棵植物，排成一排，从左到右的编号分别为：1,2,3,…,n ；n颗植物所需的水量分别为：w1,w2,w3,…wn 。小丁为植物设计了一套浇水系统。
浇水系统：每次会将连续的L棵植物分别浇1份水。每棵植物可以被重复浇水，如果当前植物已经满足所需水量，系统会将多浇的水排到水池中。
请计算浇水系统最少要浇多少次才能满足所有植物所需水量，以及排到水池的水量。
例如：n=4，L=3；4棵植物所需要的水量分别为1、1、3、2，浇水系统每次会将连续的 3 棵植物分别浇上1份水。
以下是浇水次数最少的一种方式：
第一次：将第1、2、3 棵植物分别浇上1份水，浇水后4棵植物所需水量为0、0、2、2；
第二次：将第 2、3、4 棵植物分别浇上1份水，浇水后4棵植物所需水量为0、0、1、1，由于第2棵植物已经满足所需水量，所以系统会将此次多余的1份水排到水池；
第三次：将第 2、3、4棵植物分别浇上1份水，浇水后4棵植物所需水 量为0、0、0、0，此次系统也会将第2棵植物多余的1份水排到水池； 所以，浇水系统最少需要浇3次，并且将多余的2份水排到水池。
输入描述
第一行输入两个整数n、L(1 ≤ L ≤ n ≤ 1000)，分别表示植物的数量和浇水系统每次连续浇灌的植物数量，整数之间以一个空格隔开。
第二行输入n个整数w(0 <= w; <= 1000) ，分别表示编号 1~n 的植物所需的水量，整数之间以一个空格隔开。
输出描述
输出两个整数，分别表示浇水系统最少的浇水次数，以及排到水池的水量，整数之间以一个空格隔开。
样例输入
4 3
1 1 3 2
样例输出
3 2
6. 夺取宝石
题目描述
(注.input()输入函数的括号中不允许添加任何信息)
一个n行n列的网格，表示魔塔。魔塔的每个格子中有一个怪物或一瓶药水。一名勇士，有初始体力值，从魔塔左上角入口的格子进入，到右下角出口的位置夺取宝石，夺取宝石的规则如下:
1、勇士只能从魔塔内走到右下角且每次只能向下或向右走一格;
2、怪物格子中有一个负整数，表示勇士进入该格子后会损失对应体力值;药水格子中有一个正整数，表示勇士进入该格子后，会增加对应体力值;
例如:怪物格子中的负整数为 -4 时，表示勇士进入该格子后，会损失 4体力值;药水格子中的正整数为2时，表示勇士进入该格子后，会增加 2 体力值。
3、夺取宝石全程，勇士须保持体力值大于0，否则夺取宝石失败。
给定 n行n列的魔塔，请计算勇士最少需要多少初始体力值才可以成功夺取宝石。
例如:n=3; 3行3列的魔塔如下:
按照 -1、2、-4、2、-2 的路线，当勇士初始体力值为 4时；
第一步:勇士进入-1格子，损失1体力值，体力值变为3；
第二步:勇士接着进入2格子，增加2体力值，体力值变为 5；
第三步:勇士接着进入-4格子，损失4体力值，体力值变为 1；
第四步:勇士接着进入2格子，增加2体力值，体力值变为 3；
第五步:勇士接着进入-2格子，损失2体力值，体力值变为 1。
勇士成功夺取宝石，且全程体力值均大于0，最少需要 4初始体力值。
输入描述
第一行输入一个整数n(2≤n≤200)，表示魔塔的行数和列数
接下来输入n行，每行n个整数(-1000≤整数≤1000，整数不能为 ，其中负整数表示勇士进入该怪物格子会损失的体力值，正整数表示勇士进入该药水格子会增加的体力值，整数之间以一个空格隔开
输出描述
输出一个整数，表示勇士最少需要的初始体力值
样例输入
3
-1 1-6
2 -4 1
-5 2 -2
样例输出
4
参考答案
选择题
1、B
join() 方法是字符串的一个方法，它用于将序列中的元素以指定的字符连接生成一个新的字符串。题目中是将字符串’py’使用’t’连接为一个新字符串，答案是’pty’，选B。
2、A
type() 函数是 Python 中的一个内置函数，用于获取对象的类型。x = 1, 2, 3 是定义了一个元组，所以答案为- A选项。定义元组可以省略小括号，如果定义只有一个元素的元组，元素后需要加一个逗号，例如 x = 1, 。
3、D
Python内置函数的考查，len()是获取序列长度，sum()是序列求和，sort()是序列排序，m- Ax()是求序列最大值。故选D选项。
4、B
Python中算术运算符的考查，将两个字符串拼接到一起需要使用“+”。故选择- B选项。除了能够将字符串拼接，也能够将列表. 元组拼接。
5、C
A选项：实参可以使表达式，Python会先计算出表达式的值，然后将值作为参数传递。
B选项：没有return则返回空，即None。
C选项：单星号（*），*name，接收一个元组；双星号（**），**name，接收一个字典。题目说法错误，故选- C选项。
D选项：在Python中，当你调用一个函数时，所有的位置参数（即没有指定名称的参数）必须首先出现，然后才是关键字参数（即指定了名称的参数）。这是因为Python解释器需要首先确定所有位置参数的值，然后才能将关键字参数与函数定义中的形参名称进行匹配。
编程题（仅供参考，欢迎技术交流）
1. 偶数
n = int(input())
print(n/2)2. 字母比较
m = input()
n = input()
print(max(m,n))3. 石头运输【解析算法】
li = list(eval(input().replace(' ',',')))
s = sum(li)
max_v = max(li)
ll = [max_v, s-max_v]
ll.sort()
print(ll[0],ll[1])4. 连续正整数和【枚举算法】
a = int(input())
max_cnt = -1
for c in range(2,a):
mid = a//c
if c%2==0:
if c/2*(2*mid+1) == a and mid-c/2+1>0:
max_cnt = c
# print(c,list(range(mid-c//2+1,mid+c//2+1)))
else:
if c*mid == a and mid-c/2>0:
max_cnt = c
# print(c,list(range(mid-c//2,mid+c//2+1)))
print(max_cnt)# 优化后的算法
a = int(input())
max_cnt = -1
for c in range(a,1,-1):
mid = a//c
if c%2==0:
if c/2*(2*mid+1) == a and mid-c/2+1>0:
max_cnt = c
break
# print(c,list(range(mid-c//2+1,mid+c//2+1)))
else:
if c*mid == a and mid-c/2>0:
max_cnt = c
break
# print(c,list(range(mid-c//2,mid+c//2+1)))
print(max_cnt)5. 浇花系统
# 输入数据及其处理
n, L = eval(input().replace(" ", ","))
w = list(eval(input().replace(" ", ",")))
# 算法：
# 1、找到最大的待浇灌水量 max_w 的位置 max_index；
# 2、依据 max_index，找到最小排到水池的水量时，浇灌的区间（包含 max_index）；
# 3、重复步骤 1 和 2 直至最大的待浇灌水量 max_w 为 0。
cnt = 0 # 浇灌次数
psl = 0 # 排到水池的水量
max_w = max(w) # 计算最大的待浇灌水量
while max_w > 0:
max_index = w.index(max_w)
s_index = max(0, max_index - L + 1)
t_psl_list = []
for i in range(s_index, max_index + 1):
tt = w[i : i + L]
t_psl = L - (sum(tt) - sum([max(e - 1, 0) for e in tt]))
t_psl_list.append(t_psl)
min_psl = min(t_psl_list)
min_psl_start_index = t_psl_list.index(min_psl) + s_index
for i in range(min_psl_start_index, min(min_psl_start_index + L, n)):
w[i] = max(w[i] - 1, 0)
cnt += 1
psl += min_psl
max_w = max(w)
# 输出结果
print(cnt, psl)
6. 夺取宝石【逆向思维+动态规划】
# 输入及其处理过程
n = int(input())
li = []
for _ in range(n):
temp = [int(e) for e in input().split(" ")]
li.append(temp)
# 生成初始化网格
# 【注意】不建议使用 res = [[0]*n]*n。该方法生成的列表元素地址完全相同，后续更改困难。
res = []
for i in range(n):
tt = []
for j in range(n):
tt.append(float("inf")) # 初始值为无穷大
res.append(tt)
res[n - 1][n - 1] = 1 - li[n - 1][n - 1] if li[n - 1][n - 1] < 0 else 1 # 计算最后一行最后一列的值
for i in range(n - 2, -1, -1):
res[n - 1][i] = res[n - 1][i + 1] - li[n - 1][i] # 计算出最后一行
res[i][n - 1] = res[i + 1][n - 1] - li[i][n - 1] # 计算出最后一列
# 计算剩余的值
while n > 0:
n -= 1
m = min(res[n - 1][n], res[n][n - 1])
res[n - 1][n - 1] = m - li[n - 1][n - 1] if li[n - 1][n - 1] < 0 else m
for i in range(n - 2, -1, -1):
res[n - 1][i] = res[n - 1][i + 1] - li[n - 1][i]
res[i][n - 1] = res[i + 1][n - 1] - li[i][n - 1]
# 输出结果
print(res[0][0])
# 优化后的算法
# 输入及其处理过程
n = int(input())
li = []
for _ in range(n):
temp = [int(e) for e in input().split(" ")]
li.append(temp)
# 初始化网格
# 【注意】不建议使用 res = [[0]*n]*n。该方法生成的列表元素地址完全相同，后续更改困难。
res = []
for i in range(n):
tt = []
for j in range(n):
tt.append(float("inf")) # 初始值为无穷大
res.append(tt)
# 计算网格的值
while n > 0:
m = min(res[n - 1][n], res[n][n - 1]) if n < len(li) else 1
res[n - 1][n - 1] = m - li[n - 1][n - 1] if li[n - 1][n - 1] < 0 else m
for i in range(n - 2, -1, -1):
res[n - 1][i] = res[n - 1][i + 1] - li[n - 1][i]
res[i][n - 1] = res[i + 1][n - 1] - li[i][n - 1]
n -= 1 # 缩小待计算的网格大小
# 输出结果
print(res[0][0])参考资料：CSDN博客文章
扫一扫
629
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
