第14届蓝桥杯青少组python试题解析：22年10月选拔赛

选择题

T1. 执行print (5%3) 语句后，输出的结果是 ( )

• 0
• 1
• 2
• 3

T2. 以下选项中，哪一个是乘法运算符?（）

• %
• //
• *
• **

T3. 已知x=3，求x//2+x**2的运算结果?

• 7.5
• 10
• 8
• 10.5

T4. 以下选项中，对下面程序的打印结果描述正确的是 ()

a = [1,2,3,4]
i = len(a) - 1
while i >= 0:
	print(a[i])
	i -= 1

• 把列表a倒序打印出来
• 把列表a顺序序打印出来
• 去除列表a的第一项后并以此打印出每一项
• 去除列表a的最后一项后并依次打印出每一项

编程题

T1. 最后一个字符

问题描述

编程实现输出字符串中最后一个字符。

输入描述

输入一个字符串

输出描述

输出字符串中最后一个字符

样例输入

hgf

样例输出

f

代码实现

s = input()
print(s[-1])

T2. 遥控器

问题描述

空调遥控器上的模式按钮可控制四种模式的切换。空调的初始模式为制热模式。

• 第一次按下按钮变为制冷模式
• 第二次按下按钮变为睡眠模式
• 第三次按下按钮变为除湿模式
• 第四次按下按钮变为制热模式
• 第五次按下按钮变为制冷模式
• …

以此类推。请计算出按下

N

N

N次按钮后，空调为何种模式。

输入描述

输入一个正整数

N

N

N (

1

< N < 1000 1

输出描述

输出一个大写字母，当按下模式按钮

N

N

N次后，空调为制热模式则输出

R

R

R，为制冷模式则输出

L

L

L，为睡眠模式则输出

S

S

S，为除湿模式则输出

C

C

C样例输入

样例输入

5

样例输出

L

代码实现

n = int(input())
s = 'RLSC'
print(s[n % 4])

T3. 兑换券

问题描述

小蓝有多张兑换券，这些兑换券可分为

A

A

A、

B

B

B、

C

C

C三种，且

1

1

1张

A

A

A加

1

1

1张

B

B

B加

1

1

1张

C

C

C组合可以兑换一个玩偶。

现将所有兑换券排成一排，并以字符串的形式给出，请帮助小蓝计算出现有兑换券最多可以兑换几个玩偶。

例如：字符串为

A

A

B

B

C

A

C

C

C

AABBCACCC

AABBCACCC，可以组成

2

2

2组

A

B

C

ABC

ABC，故最多可以兑换

2

2

2个玩偶。

输入描述

输入一个由

A

A

A、

B

B

B、

C

C

C三个大写字母组成的字符串 (字符串长度小于

1000

1000

1000)，表示所有的兑换券。

输出描述

输出一个整数，表示所有兑换券按照兑换要求最多可以兑换玩偶的数量。

样例输入

AABBCACCC

样例输出

2

代码实现

s = input()
A = s.count('A')
B = s.count('B')
C = s.count('C')
print(min(A, B, C)))

T4. 糖果

问题描述

现有

N

N

N罐糖果，且己知每罐糖果的初始数量。现给出两个数值

L

L

L和

R

R

R

(

L

< = R ) (L<=R) (L<=R)，需要把每罐糖果的数量调整为： L ≤ L\le L≤任意一罐糖果的数量 ≤ R \le R ≤R。

调整的方式是每次从其中一罐糖果中拿出

1

1

1块放到其他糖果罐中。请你计算出最少调整几次才能使每装糖果的数量都在

L

L

L到

R

R

R范围之间，如果不能将每罐糖果都调整到

L

L

L到

R

R

R范围之间则输出

−

1

-1

−1。

例如：

N

=

2

N=2

N=2，

2

2

2罐糖果的初始数量为

3

3

3和

8

8

8，

L

=

3

L=3

L=3，

R

=

6

R=6

R=6，通过调整使得：

3

< = 3<= 3<=任意一罐糖果的数量 < = 6 <=6 <=6，调整方式如下：

• 第一次从初始数量为

  8

  8

  8的罐中拿1块放到初始数量为

  3

  3

  3的罐中，调整后为

  (

  4

  ,

  7

  )

  (4,7)

  (4,7)

• 第二次从数量为

  7

  7

  7的罐中拿

  1

  1

  1块放到数量为

  4

  4

  4的罐中，调整后为

  (

  5

  ,

  6

  )

  (5,6)

  (5,6)

故最少调整

2

2

2次。

输入描述

输入一共

3

3

3行，第一行为一个整数

n

n

n，表示一共有

n

n

n罐糖果；第

2

2

2行为

n

n

n个整数，用空格分隔，表示每罐糖果的数量；第

3

3

3行为两个整数，用空格分隔，表示

L

L

L和

R

R

R。

输出描述

输出一个整数，表示最少调整几次才能使每装糖果的数量都在

L

L

L到

R

R

R范围之间；如果不能完成，则输出

−

1

-1

−1。

样例输入#1

2
3 8
3 6

样例输出#1

2

样例输入#2

4
4 2 2 4
3 4

样例输出#2

2

代码实现

n = int(input())
a = list(map(int, input().split()))
L, R = map(int, input().split())
z = sum(a)
# 如果不能完成，则输出-1
if z < L * n or z > R * n:
    print(-1)
else:
    ans = 0
    while True:
        a.sort()
        if a[0] >= L and a[n - 1] <= R:
            print(ans)
            break
        # 将最多的向最小的进行调整
        a[n - 1] -= 1;
        a[0] += 1
        # 计数
        ans += 1

T5. 最长路线

问题描述

有一个

N

×

M

N\times M

N×M的矩阵，且矩阵中每个方格中都有一个整数(

0

≤

0\le

0≤整数

≤

100

\le100

≤100)，小蓝需要按照以下要求从矩阵中找出一条最长的移动路线，且输出最长路线的长度 (

1

1

1个方格为

1

1

1个长度)。

要求：

1. 小蓝可以从矩阵中任意一个方格开始向它的上、下、左、右相邻的任意一个方格移动，且移动的路线不能有交叉
2. 小蓝每次所要移动到的方格中的整数都要小于当前所在方格中的整数(如当前所在的方格中的整数为

   3

   3

   3，那么可以移动到数字为

   0

   0

   0，

   1

   1

   1，

   2

   2

   2的格子里，不可以移动到数宁为

   3

   3

   3、

   4

   4

   4、

   5

   5

   5、…的格子里) ;

例如：

N

=

3

N=3

N=3，

M

=

3

M=3

M=3，矩阵方格如下图所示，最长路线为

4

→

3

→

2

→

1

→

0

4\rightarrow3\rightarrow2\rightarrow1\rightarrow0

4→3→2→1→0，最长路线的长度为

5

5

5。

输入描述

输入第一行为两个整数

n

n

n和

m

m

m，表示矩阵的大小，

n

n

n行，

m

m

m列。

接下来

n

n

n行，每行

m

m

m个整数，用空格分隔。

输出描述

输出一个整数，输出最长路线的长度。

样例输入

3 3
1 1 3
2 3 4
1 0 1

样例输出

5

代码实现

n, m = map(int, input().split())
a = []
for i in range(n):
    b = list(map(int, input().split()))
    a.append(b)
# f[i][j]表示从第i行j列出发的最长路线的长度
# 初始化二维列表
f = [[0] * (m + 1) for _ in range(n + 1)]
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]

# 记忆化搜索
def dfs(i, j):
    if f[i][j] != 0:
        return f[i][j]
    f[i][j] = 1
    for k in range(4):
        x, y = i + dx[k], j + dy[k]
        if x < 0 or x >= n or y < 0 or y >= m: # 越界检查
            continue
        if a[x][y] >= a[i][j]: # 合法性检查
            continue
        f[i][j] = max(f[i][j], dfs(x, y) + 1)
    return f[i][j]
        
ans = 0
for i in range(n):
    for j in range(m):
        ans = max(ans, dfs(i, j))
       
print(ans)