计挑赛python组初赛2020

1-1 数字与相邻的前、后数字之和可以被4整除
题目
题目描述：给定两个整数N和M(0<N<M<100000)，求N到M中满足如下条件的数字，该数字与相邻的前、后数字之和可以被4整除。比如N=3，M=9时，4、8 是满足条件的， 而5、6、7不满足，3和9因为前、后数字不在N到M中，不参与统计。
输入说明：两个正整数N和M（N<M<100000）
输出说明：满足要求的数字，如果有多个满足条件的数字，按出现次序输出前3个，如果不足3个，用-1补充。
输入样例1：11 100
输入样例2：3 9
输出样例1：12 16 20
输出样例2：4 8 -1
数据范围：(0<N<M<100000)


挺简单的

n, m = map(int,input().split())
lis=[]
for i  in range(n+1,m):
    if (3*i)%4==0:
        lis.append(i)
    if len(lis)==3:
        break
while len(lis)<3:
    lis.append(-1)
print(lis[0],lis[1],lis[2])



2-1 连续M个数之积最小
题目
题目描述：输入一个包含N个整数的数组，从中找到连续M个数之积最小的数字组合。
输入说明：第一行是两个正整数N（N<200）和M(M<10)；第二行是N个整数（每个数字Ni都是整数，且|Ni|<1000），中间用空格分开。
输出说明：最小的M个连续数字积及第一个数在数组中的位置（初始位置按1进行计算）。
输入样例：10 4
1 2 3 4 5 6 7 8 9 10
输出样例：24 1

n , m = map(int, input().split())
list1=list(map(int,input().split()))
list2=[]
for i in range(0,n-m):
    t=1
    for j in range(i,i+m):
        t*=list1[j]
    list2.append((t,i))
list2.sort()
print(list2[0][0],list2[0][1]+1)


3-1 字符串中最长连续非降序子串  挺难理解的√√√
题目
题目描述：输入一个由’a’-‘z’组成的字符串，找到字符串中出现的最长连续非降序子串，输出该子串。

输入说明：一个字符串S（长度<10000）

输出说明：字符串中最长的连续升序子串

输入样例：abcadiasiqacdfgiikkg

输出样例：acdfgiikk

数据范围：S长度<10000

代码

s = input()
start, end = 0, 0
max_len = 0
substring = ''

for i in range(1, len(s)):
    if s[i] >= s[i - 1]:
        end += 1
    else:
        if end - start + 1 > max_len:
            max_len = end - start + 1
            substring = s[start:end + 1]
        start = i
        end = i

if end - start + 1 > max_len:
    substring = s[start:end + 1]

print(substring)



官方题解：

str1 = input()
L, R, res, resL, resR = 0, 0, 0, 0, 0
while R != len(str1)-1:
    R += 1
    if str1[R] < str1[R-1]:
        if R-L-1 > res:
            res = R - L - 1
            resL = L
            resR = R
        L = R
print(str1[resL:resR])


gpt辅助理解：
这是一种使用两个指针（L和R）在字符串上滑动以找到最长连续非降序子串的方法。

1. 首先，我们定义两个指针L和R，均初始化为0，表示正在考虑的子串的开头和结尾。我们还定义了一个结果变量`res`，它将存储找到的最长子串的长度，以及`resL`和`resR`，它们将存储最长子串的起点和终点。

2. 然后，我们开始循环，到字符串结束为止：
   - 我们先将R指针向右移动一格（即`R += 1`），拓展当前正在考虑的子串。
   - 如果新考虑的字符（即`str1[R]`）比前一个字符小（即`str1[R] < str1[R-1]`），那么当前子串就不再是非降序的，我们需要开始寻找新的子串。
   - 在开始新的子串之前，我们检查当前子串的长度`R - L - 1`是否比之前找到的最长子串`res`还要长。如果是的话，我们用当前子串的长度更新`res`，并且用L和R更新`resL`和`resR`。
   - 然后，我们用R更新L，表示开始新的子串。

3. 最后，我们打印出最长的非降序子串，即`str1[resL:resR]`。

这个代码中，我们一直在找非降序子串的结束点（即那些比前一个字符小的字符），然后在找到新的结束点时更新最长子串。这种方法的好处是，我们总是能找到最长的子串，因为我们在每次找到子串结束时都进行了检查和更新。而且，由于我们是从左到右扫描字符串的，所以我们总是能找到最左边的最长连续非降序子串。



3-2 病毒信息筛选
题目
题目描述：
计算网络数据包中的可能被注入病毒片段信息，经过长期观察发现，计算机病毒文件源码中往往包含“_1234.exe”的字符片段。现在请你开发一个计算程序，辅助信息专家检测这个病毒嫌疑特征。

输入说明：一个字符串S

输出说明：字符串中包含”_1234.exe”字符片段的位置，如果包含多个病毒嫌疑特征片段，输出数量后，再输出每个片段的位置。如果没有检测到病毒嫌疑片段，就输出0

输入样例：ox123_0212_3323_1234.exe20202020202_1234.exe

输出样例：2 15 35


代码

s=input()
count=0
l=[]
for i in range(len(s)):
	if s[i:i+9]=="_1234.exe":
		count+=1
		l.append(i)
print(count,end=' ')
for j in l:
    print(j,end=' ')


官方题解（看起来较复杂）：
S = input()
result = []
count = 0
if "_1234.exe" not in S:
    print(0)
else:
    listStr = list(S)
    for i in range(0, len(listStr)):
        if i + 9 <= len(listStr):
            tempStr = listStr[i:i+9]
            if tempStr == list("_1234.exe"):
                result.append(i)
                count += 1
    if count != 1:
        print(count,end=' ')
    for i in result:
        print(i,end=' ')



3-3 货物摆放
题目
题目描述：
便利店拟上架一批货物，为了便于顾客找到物品，店长尝试按照货物的颜色对这批商品进行摆放，已知这批货物的名称和颜色，请你按照颜色的字母顺序对这批货物进行处理，给出货物摆放的次序。

输入说明：第一行是一个整数N，表明这批货物的数量；接下来N行是货物名称S和颜色信息T，S和T都是字符串，中间用空格分开。

输出说明：输出按颜色字母序排序摆放的货品次序。如果有2个物品的颜色相同，按照货品名称字母排序。

输入样例：
6
FastNoodle    Red
Cake         Orange
RiceRoll       Black
Sandwich     Yellow
Cheese       Blue
Milk         White

输出样例：
RiceRoll Cheese Cake FastNoodle Milk Sandwich

代码用内置函数排序：
N = int(input())
products = []
for _ in range(N):
    product, color = input().strip().split()
    products.append((color, product))
products = sorted(products)
for color, product in products:
    print(product, end=' ')


官方代码：
Num = eval(input())
listGoods = []
for i in range(Num):
    tmp = input()
    listGoods.append((tmp.split()[0], tmp.split()[1]))
listGoods.sort(key=lambda x:x[1])
for i in listGoods:
    print(i[0], end='  ')


4-1 游戏地图选洼地  建立二维数组非numpy  √
题目
题目描述：
游戏中的地图都是用二维数组表达的，每个位置表示一个整数表示高度，现在需要找出地图中的洼地放置宝物。已知表示地图中各点的高度，用二维数组存放，请找出其中最低的洼地。二维地图中洼地的定义是该点上、下、左、右四个方向的高度值都大于该点的高度值（边界上的点不满足洼地的定义）。

输入说明：第一行是整数N(0<N<1001)，表示二维数组的行数和列数。接下来是一个N行、N列的二维整数矩阵，每个数字表示地图上该点处的地面高度Hij(0<Hij<2020)。

输出说明：用于藏宝的最低洼地的位置坐标i、j（1<=i,j<=N），其中i表示行，j表示列。如果不存在满足条件的山峰，输出-1 -1。测试数据不存在多个同样高度的最低洼地。

输入样例：
6
0 3 0 0 1 1
0 6 0 1 1 1
9 9 9 7 5 3
6 5 3 5 3 3
5 6 6 6 7 6
3 4 4 5 5 5
输出样例：4 3

代码

n=int(input())
b,c = -1, -1
list = []
for _ in range(n):
    row = [int(x) for x in input().split()] # 建立二维数组非numpy
    list.append(row)
if n<3:
    print(b,c)
    # exit()
else:
    for i in range(1,n-1):
        for j in range(1,n-1):
            if list[i-1][j]>list[i][j] and list[i+1][j]>list[i][j] and list[i][j-1]>list[i][j] and list[i][j+1]>list[i][j]:
                b,c=i,j
    print(b+1,c+1)

参考代码：


Map = []
res, resI, resJ = 2021, -1, -1
Col = eval(input())
for i in range(Col):
    Map.append(list(map(int, input().split())))
if Col < 3:
    print("-1 -1")
    exit()
for i in range(1, Col-1):
    for j in range(1, Col-1):
        if Map[i][j] < Map[i-1][j] and Map[i][j] < Map[i+1][j] and Map[i][j] < Map[i][j-1] and Map[i][j] < Map[i][j+1]:
            if Map[i][j] < res:
                res, resI, resJ = Map[i][j], i, j
print(resI+1, resJ+1)