2022年十三届省赛python组试题及解析_输入两个字符串,装饰后输出。 输入格式: 第一行输入一个字符串s。 第二行输入一个

第一题：

题目描述：

(注.input()输入函数的括号中不允许添加任何信息)

编程实现：

输入两个字符串S1和S2，然后将S1和S2拼接成一个字符串并输出。例如：S1 =“ab”，S2 =“cd”，拼接成一个字符串为“abcd”

输入描述：

第一行输入一个字符串S1第二行输入一个字符串S2

输出描述：

将S2拼接到S1的后边并输出

样例输入：

ab

cd

样例输出：

abcd

S1=input()
S2=input()
print(S1+S2)

第二题：

题目描述：

(注.input()输入函数的括号中不允许添加任何信息)

编程实现：

给定一个正整数N，输出正整数N中各数位最大的那个数字。

例如：N=132，则输出3。

输入描述：

输入一个正整数N

输出描述：

输出正整数N中各数位最大的那个数字

样例输入：

132

样例输出：

3

N = input()
ls = []
for i in N:
    ls.append(int(i))
print(max(ls))
​

第三题：

题目描述：

(注.input()输入函数的括号中不允许添加任何信息)

编程实现：

小青带着一根长为80厘米的竹竿去摘苹果，当伸手碰不到的苹果会借助竹竿摘苹果（竹竿碰到苹果就算摘下）。在给出小青伸手的高度N及每个苹果离地面的高度，请你帮助小青计算出最多能够摘到多少个苹果。例如：N=120，苹果高度分别为130,220,153,200，最多可以摘到3个苹果，高度为220的苹果即使用竹竿也摘不到。

输入描述：

第一行输入一个正整数N（120≤N≤200），表示小青伸手高度（单位：厘米）第二行输入多个正整数，表示每个苹果距离地面的高度，正整数之间以一个英文逗号隔开（单位：厘米）

输出描述：

输出一个整数，表示小青最多可以摘到的苹果数

样例输入：

120

130,220,153,200

样例输出：

3

N=int(input())
M=list(map(int,input().split(',')))  
s=0
for i in M:
    if N+80 >= i:
        s+=1
print(s)

第四题：

题目描述：

(注.input()输入函数的括号中不允许添加任何信息)

编程实现：

小马需要将N件物品从河的一岸搬运到河的另一岸，每次搬运的物品为1到3件。请问小马将N件物品全部搬运过去有多少种方案。例如：N=3，将3件物品全部搬运过去有4种方案：方案一：第一次搬运1件，第二次搬运1件，第三次搬运1件；方案二：第一次搬运1件，第二次搬运2件；方案三：第一次搬运2件，第二次搬运1件；方案四：一次搬运3件。

输入描述：

输入一个正整数N，表示需要搬运的物品数

输出描述：

输出将N件物品全部搬运过去有多少种方案

样例输入：

3

样例输出：

4

N = int(input())  # 输入一个数(代表物品数)
def f(N):  # 创建一个递归函数
    if N == 1:  # 当N等于1、2、3时,结果没有规律，所以直接返回结果
        return 1
    elif N == 2:
        return 2
    elif N == 3:
        return 4
    else:
        return f(N-1)+f(N-2)+f(N-3)  # 规律直接用：N的方案数=(N-1的方案数)+(N-2的方案数)+(N-3的方案数)
print(f(N))  # 最终打印结果
​

第五题：

题目描述：

(注.input()输入函数的括号中不允许添加任何信息)

编程实现：

有一片海域划分为NM个方格，其中有些海域已被污染（用0表示），有些海域没被污染（用1表示）。请问这片NM海域中有几块是没被污染的独立海域（没被污染的独立海域是指该块海域上下左右被已污染的海域包围，且N*M以外的海域都为已被污染的海域）

例如：N=4，M=5，4*5的海域中，已被污染海域和没被污染的海域如下图：

这块4*5的海域，有3块海域（绿色）没被污染，因为每一块的上下左右都被污染的海域包围。

输入描述：

第一行输入两个正整数N和M，N表示矩阵方格的行，M表示矩阵方格的列，N和M之间以一个英文逗号隔开。第二行开始输入N行，每行M个数字（数字只能为1或者0，1表示没被污染的海域，0表示已被污染的海域）

输出描述：

输出一个整数，表示N*M的海域中有几块是没被污染的独立海域

样例输入：

4,5

1,1,0,0,0

1,0,1,0,0

1,0,0,0,0

1,1,0,1,1

样例输出：

3

这个题就是一个矩阵问题。
我们来看一下题：它默认外围都是0的污染海域，然后没有被污染的就代表上下左右都是0的地方。这个其实就是很经典的算法问题，就做孤岛算法。
题中说要输入两个正整数N和M，然后第二行开始输入N行，显然要使用循环。
n = 4
m = 5
lst = [[1, 1, 0, 0, 0],
       [1, 0, 1, 0, 0],
       [1, 0, 0, 0, 0],
       [1, 1, 0, 1, 1]]
这个列表是不是就是题中所要求的列表，我们现在就是要将其输出出来。
n,m = map(int,input().split(','))
lst=[]
for i in range(n):
    lst.append(list(map(int,input().split(','))))
print(lst)      # 现在的结果是不是和我们上面的那个一样，只不过我上面写的换行了，打印的这个没有换行。
接下来我们就需要每一行每一列的去检查，当我检查第一个数据，数据为0的时候，我们就不用管，因为它不是岛；如果发现是1，我们就要认为它是一个岛，那么我们就让岛的统计数据加1，同时让岛的表示从1变成0，为什么要变成0呢。因为我们要检查完这个之后还要检查它的四周，看他是不是连起来的一大片的岛。比如说，如果我们有将其变成0，现在第一行第一个检查完了，岛数加1，到了第二行是不是还是1，那岛数计算是不是还是要加1的，这样是不是就会重复计算了。
我们先按照这个思路写一遍。
​
作用：我们一下这个数据是否是0，如果是0就代表着污染海水，我们就不用再去管他。
    如果我发现它是1，那我们就需要判断它的四周是否是1，如果它的四周还是1，那么继续往外扩散，就像病毒扩散一样。这是不是就可以把所有的边界都探索出来。如果是0呢，那么直接返回就行了。
def dfs(lst, i, j):
    if not 0 <= i < len(lst) or not 0 <= j < len(lst[0]) or lst[i][j] == 0:            # 这个就是判断这个数据是0的时候，我们直接返回空就行了
        return
    lst[i][j] = 0
    dfs(lst, i+1, j)
    dfs(lst, i-1, j)
    dfs(lst, i, j+1)
    dfs(lst, i, j-1)
​
​
island = 0
for i in range(n):
    for j in range(m):
        if lst[i][j] == 1:
            island += 1
            dfs(lst, i, j)
​
print(island)

第六题：

题目描述：

(注.input()输入函数的括号中不允许添加任何信息)

编程实现：

有一个NM的矩阵方格，其中有些方格中有奖品，有些方格中没有奖品。小蓝需要从NM的矩阵中选择一个正方形区域，如果所选的正方形区域的一条对角线方格中都有奖品，其他方格都没有奖品，就会获得所选区域中的所有奖品，否则不能获得奖品。当给出N和M的值，及N*M的矩阵方格中摆放的奖品情况（0表示方格中没有奖品，1表示方格中有奖品），请你帮助小蓝找出一个正方形区域，能够获得数量最多的奖品，并将奖品数输出。

例如：N=5，M=6，奖品情况如下：

选择上图红色正方形区域，可以获得最多的4个奖品。

输入描述：

第一行输入两个整数N和M（1≤N≤100，1≤M ≤100），N表示矩阵的行数，M表示矩阵的列数，两个整数之间一个空格隔开。接下来输入N行，每行包括M个0或者1（0表示方格中没有奖品，1表示方格中有奖品），0或者1之间一个空格隔开

输出描述：

输出一个整数，表示最多可获得的奖品数

样例输入：

5 6

1 0 1 0 0 0

0 1 0 1 0 0

1 0 0 0 1 0

0 1 0 0 0 1

1 0 1 0 0 0

样例输出：

4

这个题是什么意思呢，就是说要在这个5×6的方格中，找到一个方格，里面对角线上都是1其余部分都是0，就像图中给画出的那个红色线的方格。其实还有，就像左上角也符合要求，只不过我们要的是最多的。
其实呢，这个就是一个深度遍历的题。什么是深度遍历呢？
深度遍历是先往一个方向一直遍历，直到尽头，然后再回溯到上一个节点，再从其他方向遍历，循环往复，直到遍历所有的节点。
我们看一下这个题，先说思路哈。
思路就是，我们先去查也就是一个个去遍历，比如这个是一个5×6的，也就是30个格子，当遍历到元素等于1的时候，那我们就往它的斜角方向去遍历（可以右斜角也可以左斜角）。
直到什么结束呢，就是超出这个区域了，或者碰到0了。停下来之后，我们是不是应该去检查里面的数了，是不是只有对角线有1。只有对角线有1，那就是说方格内所有的数加起来等于行数或者列数。 
n,m = list(map(int,input().split(' ')))
lst = []
for i in range(n):
    lst.append(list(map(int,input().split(' '))))
print(lst)
​
接下来，我们就写一个主函数，就是一个个去遍历。（先写右深度遍历）
n, m = 5, 6
lst = [[1, 0, 1, 0, 0, 0],
       [0, 1, 0, 1, 0, 0],
       [1, 0, 0, 0, 1, 0],
       [0, 1, 0, 0, 0, 1],
       [1, 0, 1, 0, 0, 0]]
​
​
def SUM(lst, start_i, start_j, r, c):  # r:行   c：列
    sum_s = 0
    for i in range(start_i, r + 1):
        sum_s += sum(lst[i][min(start_j, c):max(start_j, c) + 1])  # 因为左求和、右求和我们都会调用求和函数。我们需要把本身包含进去，最后+1
    return sum_s
​
​
def dfsR(lst, start_i, start_j, i, j):
    # 这个是超过边界或者碰到0的情况
    if i >= n or j >= m or lst[i][j] == 0:
        return 0
    # 这个是合不等于行数的情况
    elif SUM(lst, start_i, start_j, i, j) != i - start_i + 1:
        return 0
    else:
        return dfsR(lst, start_i, start_j, i + 1, j + 1) + 1  # 最后+1，是为了让结果+1。
​
​
res = 0  # 最后输出的结果
for i in range(n):
    for j in range(m):
        if lst[i][j] == 1:  # 我们只有等于1的时候才会做出操作。
            start_i, start_j = i, j
            # 右深度遍历
            res_r = dfsR(lst, start_i, start_j, i, j)  # start_i和start_j开始遍历的点i和j，i，j就负责子矩阵里面进行遍历。
​
        res = max(res_r, res)
print(res)
​
​
然后我们接下来把左深度遍历补充完整，就是我们最终的代码。
n,m = list(map(int,input().split(' ')))
lst = []
for i in range(n):
    lst.append(list(map(int,input().split(' '))))
print(lst)
​
def SUM(lst, start_i, start_j, r, c):  # r:行   c：列
    sum_s = 0
    for i in range(start_i, r + 1):
        sum_s += sum(lst[i][min(start_j, c):max(start_j, c) + 1])  # 因为左求和、右求和我们都会调用求和函数。我们需要把本身包含进去，最后+1
    return sum_s
​
​
def dfsR(lst, start_i, start_j, i, j):
    # 这个是超过边界或者碰到0的情况
    if i >= n or j >= m or lst[i][j] == 0:
        return 0
    # 这个是合不等于行数的情况
    elif SUM(lst, start_i, start_j, i, j) != i - start_i + 1:
        return 0
    else:
        return dfsR(lst, start_i, start_j, i + 1, j + 1) + 1  # 最后+1，是为了让结果+1。
​
​
def dfsL(lst, start_i, start_j, i, j):
    # 这个是超过边界或者碰到0的情况
    if i >= n or j <0 or lst[i][j] == 0:
        return 0
    # 这个是合不等于行数的情况
    elif SUM(lst, start_i, start_j, i, j) != i - start_i + 1:
        return 0
    else:
        return dfsL(lst, start_i, start_j, i + 1, j - 1) + 1  # 最后+1，是为了让结果+1。
​
​
res = 0  # 最后输出的结果
for i in range(n):
    for j in range(m):
        if lst[i][j] == 1:  # 我们只有等于1的时候才会做出操作。
            start_i, start_j = i, j
            # 右深度遍历
            res_r = dfsR(lst, start_i, start_j, i, j)  # start_i和start_j开始遍历的点i和j，i，j就负责子矩阵里面进行遍历。
            # 左深度遍历
            res_l = dfsL(lst, start_i, start_j, i, j)
        res = max(res_r, res_l, res)
print(res)
​