ccf python写题随手记

目录

13-12-1  13-12-2

14-03-1  14-03-2  14-09-1  14-09-2  14-12-1  14-12-2

15-03-1  15-03-2  15-09-1  15-09-2  15-12-1   15-12-2

16-04-1  16-04-2  16-09-1  16-09-2  16-12-1  16-12-2

17-03-1  17-03-2  17-09-1  17-09-2  17-12-1  17-12-2 

18-03-1  18-03-2  18-09-1  18-09-2  18-12-1  18-12-2

19-03-1  19-03-2  19-09-1  19-09-2  19-12-1  19-12-2

20-06-1  20-06-2  20-09-1  20-09-2  20-12-1  20-12-2  

21-04-1  21-04-2

（小声说道）本人之前用python刷题时编写的代码，大部分都可以满分通过，但是难免有漏网之鱼可能编写不通过-_-||，因为我忘记了

目前转用java重新刷题，有需要可以自取

https://mp.csdn.net/mp_blog/creation/editor/124959973

13-12-1

'''
问题描述
　　给定n个正整数，找出它们中出现次数最多的数。如果这样的数有多个，请输出其中最小的一个。
输入格式
　　输入的第一行只有一个正整数n(1 ≤ n ≤ 1000)，表示数字的个数。
　　输入的第二行有n个整数s1, s2, …, sn (1 ≤ si ≤ 10000, 1 ≤ i ≤ n)。相邻的数用空格分隔。
输出格式
　　输出这n个次数中出现次数最多的数。如果这样的数有多个，输出其中最小的一个。
样例输入
6
10 1 10 20 30 20
样例输出
10
'''
n = eval(input())
s = [int(s) for s in input().split()]
dict1 = {}
for item in s:
    dict1[item] = dict1.get(item, 0) + 1
items = list(dict1.items())
items.sort()
items.sort(key = lambda x: x[1], reverse = True)
print(int(items[0][0]))

13-12-2

'''
问题描述
识别码的计算方法如下：
　　首位数字乘以1加上次位数字乘以2……以此类推，用所得的结果mod 11，所得的余数即为识别码，如果余数为10，则识别码为大写字母X。例如ISBN号码0-670-82162-4中的识别码4是这样得到的：对067082162这9个数字，从左至右，分别乘以1，2，…，9，再求和，即0×1+6×2+……+2×9=158，然后取158 mod 11的结果4作为识别码。
　　编写程序判断输入的ISBN号码中识别码是否正确，如果正确，则仅输出“Right”；如果错误，则输出是正确的ISBN号码。
输入格式
　　输入只有一行，是一个字符序列，表示一本书的ISBN号码（保证输入符合ISBN号码的格式要求）。
输出格式
　　输出一行，假如输入的ISBN号码的识别码正确，那么输出“Right”，否则，按照规定的格式，输出正确的ISBN号码（包括分隔符“-”）。
样例输入
0-670-82162-4
样例输出
Right
样例输入
0-670-82162-0
样例输出
0-670-82162-4
'''
isbn = input().split("-")
isbns = isbn[0]+isbn[1]+isbn[2]
sum = 0
for i in range(1,10):
    sum += int(isbns[i-1])*i
toto = sum%11
if toto == 10:
    if isbn[3] =="X":
        print("Right")
    else:
        print(isbn[0] + "-" + isbn[1] + "-" + isbn[2] + "-" + "X")
else:
    if isbn[3] == "X" or isbn[3]!=str(toto):
        print(isbn[0] + "-" + isbn[1] + "-" + isbn[2] + "-" + str(toto % 11))
    else:
        print("Right")

14-03-1

'''
相反数
问题描述
　　有 N 个非零且各不相同的整数。请你编一个程序求出它们中有多少对相反数(a 和 -a 为一对相反数)。
输入格式
　　第一行包含一个正整数 N。(1 ≤ N ≤ 500)。
　　第二行为 N 个用单个空格隔开的非零整数,每个数的绝对值不超过1000,保证这些整数各不相同。
输出格式
　　只输出一个整数,即这 N 个数中包含多少对相反数。
样例输入
5
1 2 3 -1 -2
样例输出
2
'''
n = eval(input())
s = [abs(int(s)) for s in input().split()]
dict1 = {}
for item in s:
    dict1[item] = dict1.get(item, 0) + 1
print(n-len(dict1))

14-03-2

'''
窗口
问题描述
　　在某图形操作系统中,有 N 个窗口,每个窗口都是一个两边与坐标轴分别平行的矩形区域。窗口的边界上的点也属于该窗口。窗口之间有层次的区别,在多于一个窗口重叠的区域里,只会显示位于顶层的窗口里的内容。
　　当你点击屏幕上一个点的时候,你就选择了处于被点击位置的最顶层窗口,并且这个窗口就会被移到所有窗口的最顶层,而剩余的窗口的层次顺序不变。如果你点击的位置不属于任何窗口,则系统会忽略你这次点击。
　　现在我们希望你写一个程序模拟点击窗口的过程。
输入格式
　　输入的第一行有两个正整数,即 N 和 M。(1 ≤ N ≤ 10,1 ≤ M ≤ 10)
　　接下来 N 行按照从最下层到最顶层的顺序给出 N 个窗口的位置。 每行包含四个非负整数 x1, y1, x2, y2,表示该窗口的一对顶点坐标分别为 (x1, y1) 和 (x2, y2)。保证 x1 < x2,y1 2。
　　接下来 M 行每行包含两个非负整数 x, y,表示一次鼠标点击的坐标。
　　题目中涉及到的所有点和矩形的顶点的 x, y 坐标分别不超过 2559 和　　1439。
输出格式
　　输出包括 M 行,每一行表示一次鼠标点击的结果。如果该次鼠标点击选择了一个窗口,则输出这个窗口的编号(窗口按照输入中的顺序从 1 编号到 N);如果没有,则输出"IGNORED"(不含双引号)。
样例输入
3 4
0 0 4 4
1 1 5 5
2 2 6 6
1 1
0 0
4 4
0 5
样例输出
2
1
1
IGNORED
样例说明
　　第一次点击的位置同时属于第 1 和第 2 个窗口,但是由于第 2 个窗口在上面,它被选择并且被置于顶层。
　　第二次点击的位置只属于第 1 个窗口,因此该次点击选择了此窗口并将其置于顶层。现在的三个窗口的层次关系与初始状态恰好相反了。
　　第三次点击的位置同时属于三个窗口的范围,但是由于现在第 1 个窗口处于顶层,它被选择。
　　最后点击的 (0, 5) 不属于任何窗口。
'''

def panduan(position,window):
    x,y = position
    x1,y1,x2,y2 = window[1]
    return x1<=x<=x2 and y1<=y<=y2
windows = []
N,M = [int(s) for s in input().split()]
for i in range(N):
    window = [int(s) for s in input().split()]
    windows.append((i+1,window))
for i in range(M):
    x,y = [int(s) for s in input().split()]
    for j in range(N-1,-1,-1):
        if panduan((x,y),windows[j]):
            print(windows[j][0])
            w = windows.pop(j)
            windows.append(w)
            break
    else:
        print("IGNORED")

14-09-1

'''
相邻数对
问题描述
　　给定n个不同的整数，问这些数中有多少对整数，它们的值正好相差1。
输入格式
　　输入的第一行包含一个整数n，表示给定整数的个数。
　　第二行包含所给定的n个整数。
输出格式
　　输出一个整数，表示值正好相差1的数对的个数。
样例输入
6
10 2 6 3 7 8
样例输出
3
样例说明
　　值正好相差1的数对包括(2, 3), (6, 7), (7, 8)。
评测用例规模与约定
　　1<=n<=1000，给定的整数为不超过10000的非负整数。
'''
n = eval(input())
s = [int(s) for s in input().split()]
s.sort()
num = 0
for i in range(n-1):
    a = s[i+1]-s[i]
    if a == 1:
        num+=1
print(num)

# for item in s:
#     dict1[item] = dict1.get(item, 0) + 1
# print(n-len(dict1))

14-09-2

'''
画图
问题描述
　　在一个定义了直角坐标系的纸上，画一个(x1,y1)到(x2,y2)的矩形指将横坐标范围从x1到x2，纵坐标范围从y1到y2之间的区域涂上颜色。
　　下图给出了一个画了两个矩形的例子。第一个矩形是(1,1) 到(4, 4)，用绿色和紫色表示。第二个矩形是(2, 3)到(6, 5)，用蓝色和紫色表示。图中，一共有15个单位的面积被涂上颜色，其中紫色部分被涂了两次，但在计算面积时只计算一次。在实际的涂色过程中，所有的矩形都涂成统一的颜色，图中显示不同颜色仅为说明方便。

　　给出所有要画的矩形，请问总共有多少个单位的面积被涂上颜色。
输入格式
　　输入的第一行包含一个整数n，表示要画的矩形的个数。
　　接下来n行，每行4个非负整数，分别表示要画的矩形的左下角的横坐标与纵坐标，以及右上角的横坐标与纵坐标。
输出格式
　　输出一个整数，表示有多少个单位的面积被涂上颜色。
样例输入
2
1 1 4 4
2 3 6 5
样例输出
15
评测用例规模与约定
　　1<=n<=100，0<=横坐标、纵坐标<=100。
'''

n = eval(input())
cell = set()
for i in range(n):
    x1, y1, x2, y2 = [int(s) for s in input().split()]
    x_step = 1 if x1<=x2 else -1
    y_step = 1 if y1 <= y2 else -1
    for x in range(x1, x2, x_step):
        for y in range(y1, y2, y_step):
            cell.add((x, y))
print(len(cell))

14-12-1

'''
门禁系统
问问题描述
　　涛涛最近要负责图书馆的管理工作，需要记录下每天读者的到访情况。每位读者有一个编号，每条记录用读者的编号来表示。给出读者的来访记录，请问每一条记录中的读者是第几次出现。
输入格式
　　输入的第一行包含一个整数n，表示涛涛的记录条数。
　　第二行包含n个整数，依次表示涛涛的记录中每位读者的编号。
输出格式
　　输出一行，包含n个整数，由空格分隔，依次表示每条记录中的读者编号是第几次出现。
样例输入
5
1 2 1 1 3
样例输出
1 1 2 3 1
评测用例规模与约定
　　1≤n≤1,000，读者的编号为不超过n的正整数。
'''
n = eval(input())
s = [int(s) for s in input().split()]
dict1={}
for item in s:
    dict1[item] = dict1.get(item, 0) + 1
    print(dict1[item],end=" ")

14-12-2

'''
Z字形扫描
问题描述
　　在图像编码的算法中，需要将一个给定的方形矩阵进行Z字形扫描(Zigzag Scan)。给定一个n×n的矩阵，Z字形扫描的过程如下图所示：

　　对于下面的4×4的矩阵，
　　1 5 3 9
　　3 7 5 6
　　9 4 6 4
　　7 3 1 3
　　对其进行Z字形扫描后得到长度为16的序列：
　　1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
　　请实现一个Z字形扫描的程序，给定一个n×n的矩阵，输出对这个矩阵进行Z字形扫描的结果。
输入格式
　　输入的第一行包含一个整数n，表示矩阵的大小。
　　输入的第二行到第n+1行每行包含n个正整数，由空格分隔，表示给定的矩阵。
输出格式
　　输出一行，包含n×n个整数，由空格分隔，表示输入的矩阵经过Z字形扫描后的结果。
样例输入
4
1 5 3 9
3 7 5 6
9 4 6 4
7 3 1 3
样例输出
1 5 3 9 7 3 9 5 4 7 3 6 6 4 1 3
评测用例规模与约定
　　1≤n≤500，矩阵元素为不超过1000的正整数。
'''
n = eval(input())
ju = []
for q in range(n):
    s = [int(s) for s in input().split()]
    ju.append(s)
i, j = 0,0
print(ju[0][0],end=" ")
while i < n and j < n:
    if i == 0:
        j += 1
        while n>i>=0 and n>j>=0:
            print(ju[i][j],end=" ")
            i+=1
            j-=1
        else:
            j += 1
            i -= 1

    if i+1==n :
        j += 1
        while ii>=0 and n>j>=0:
            print(ju[i][j],end=" ")
            j+=1
            i-=1
        else:
            i += 1
            j -= 1


    if j+1==n:
        i += 1
        while i < n and j < n:
            print(ju[i][j], end=" ")
            if i==j==n-1:
                break
            i += 1
            j -= 1

        else:
            j += 1
            i -= 1

15-03-1

'''
图像旋转
问题描述
　　旋转是图像处理的基本操作，在这个问题中，你需要将一个图像逆时针旋转90度。
　　计算机中的图像表示可以用一个矩阵来表示，为了旋转一个图像，只需要将对应的矩阵旋转即可。
输入格式
　　输入的第一行包含两个整数n, m，分别表示图像矩阵的行数和列数。
　　接下来n行每行包含m个整数，表示输入的图像。
输出格式
　　输出m行，每行包含n个整数，表示原始矩阵逆时针旋转90度后的矩阵。
样例输入
2 3
1 5 3
3 2 4
样例输出
3 4
5 2
1 3
评测用例规模与约定
　　1 ≤ n, m ≤ 1,000，矩阵中的数都是不超过1000的非负整数。
'''
a,b = [int(s) for s in input().split()]
juzhen = []
for i in range(a):
    x = [int(s) for s in input().split()]
    juzhen.append(x)
for j in range(b-1,-1,-1):
    for i in range(a):
        print(juzhen[i][j],end=" ")
    print()

15-03-2

'''
数字排序
问题描述
　　给定n个整数，请统计出每个整数出现的次数，按出现次数从多到少的顺序输出。
输入格式
　　输入的第一行包含一个整数n，表示给定数字的个数。
　　第二行包含n个整数，相邻的整数之间用一个空格分隔，表示所给定的整数。
输出格式
　　输出多行，每行包含两个整数，分别表示一个给定的整数和它出现的次数。按出现次数递减的顺序输出。如果两个整数出现的次数一样多，则先输出值较小的，然后输出值较大的。
样例输入
12
5 2 3 3 1 3 4 2 5 2 3 5
样例输出
3 4
2 3
5 3
1 1
4 1
评测用例规模与约定
　　1 ≤ n ≤ 1000，给出的数都是不超过1000的非负整数。
'''

n = eval(input())
s = [int(s) for s in input().split()]
dict1 = {}
for item in s:
    dict1[item] = dict1.get(item, 0) + 1
dict2 = sorted(dict1.items(),key=lambda item:item[0])
dict3 = sorted(dict2,key=lambda item:item[1],reverse=True)
for item in dict3:
    print(item[0],item[1])

15-09-1

'''
数列分段
问题描述
　　给定一个整数数列，数列中连续相同的最长整数序列算成一段，问数列中共有多少段？
输入格式
　　输入的第一行包含一个整数n，表示数列中整数的个数。
　　第二行包含n个整数a1, a2, …, an，表示给定的数列，相邻的整数之间用一个空格分隔。
输出格式
　　输出一个整数，表示给定的数列有多个段。
样例输入
8
8 8 8 0 12 12 8 0
样例输出
5
样例说明
　　8 8 8是第一段，0是第二段，12 12是第三段，倒数第二个整数8是第四段，最后一个0是第五段。
评测用例规模与约定
　　1 ≤ n ≤ 1000，0 ≤ ai ≤ 1000。
'''


n = eval(input())
li = [int(s) for s in input().split()]
num = 0
ty = -1
for i in li:
    if i != ty:
        num+=1
    ty = i
print(num)

15-09-2

'''
日期计算
问题描述
　　给定一个年份y和一个整数d，问这一年的第d天是几月几日？
　　注意闰年的2月有29天。满足下面条件之一的是闰年：
　　1） 年份是4的整数倍，而且不是100的整数倍；
　　2） 年份是400的整数倍。
输入格式
　　输入的第一行包含一个整数y，表示年份，年份在1900到2015之间（包含1900和2015）。
　　输入的第二行包含一个整数d，d在1至365之间。
输出格式
　　输出两行，每行一个整数，分别表示答案的月份和日期。
样例输入
2015
80
样例输出
3
21
样例输入
2000
40
样例输出
2
9
'''

y = eval(input())
d = eval(input())
ri = [31,28,31,30,31,30,31,31,30,31,30,31]
if y%400==0 or (y%4==0 and y%100!=0):
    ri[1]+=1
dd=d
for i in range(12):
    dd = dd-ri[i]
    if dd<=0:
        print(i+1)
        print(ri[i]+dd)
        break

15-12-1 

'''
数位之和
问题描述
　　给定一个十进制整数n，输出n的各位数字之和。
输入格式
　　输入一个整数n。
输出格式
　　输出一个整数，表示答案。
样例输入
20151220
样例输出
13
样例说明
　　20151220的各位数字之和为2+0+1+5+1+2+2+0=13。
评测用例规模与约定
　　所有评测用例满足：0 ≤ n ≤ 1000000000。
'''


d = input()
summ = 0
for i in d:
    summ+=int(i)
print(summ)

15-12-2

'''
消除类游戏
问题描述
　　消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。
　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。
　　请注意：一个棋子可能在某一行和某一列同时被消除。
输入格式
　　输入的第一行包含两个整数n, m，用空格分隔，分别表示棋盘的行数和列数。
　　接下来n行，每行m个整数，用空格分隔，分别表示每一个方格中的棋子的颜色。颜色使用1至9编号。
输出格式
　　输出n行，每行m个整数，相邻的整数之间使用一个空格分隔，表示经过一次消除后的棋盘。如果一个方格中的棋子被消除，则对应的方格输出0，否则输出棋子的颜色编号。
样例输入
4 5
2 2 3 1 2
3 4 5 1 4
2 3 2 1 3
2 2 2 4 4
样例输出
2 2 3 0 2
3 4 5 0 4
2 3 2 0 3
0 0 0 4 4
样例说明
　　棋盘中第4列的1和第4行的2可以被消除，其他的方格中的棋子均保留。
样例输入
4 5
2 2 3 1 2
3 1 1 1 1
2 3 2 1 3
2 2 3 3 3
样例输出
2 2 3 0 2
3 0 0 0 0
2 3 2 0 3
2 2 0 0 0
样例说明
　　棋盘中所有的1以及最后一行的3可以被同时消除，其他的方格中的棋子均保留。
评测用例规模与约定
　　所有的评测用例满足：1 ≤ n, m ≤ 30。
'''

import copy
n,m = [int(s) for s in input().split()]
ge = []
for i in range(n):
    dian = [int(s) for s in input().split()]
    ge.append(dian)
dite = copy.deepcopy(ge)

for i in range(n):
    for j in range(m-2,0,-1):
        if ge[i][j] == ge[i][j-1] == ge[i][j+1]:
            dite[i][j] = dite[i][j - 1] = dite[i][j +1] = 0
for i in range(n-2,0,-1):
    for j in range(m):
        if ge[i][j] == ge[i-1][j] == ge[i+1][j]:
            dite[i][j] = dite[i - 1][j] = dite[i +1][j] = 0

for i in dite:
    for j in i:
        print(j,end=" ")
    print()

16-04-1

'''
折点计数
问题描述
　　给定n个整数表示一个商店连续n天的销售量。如果某天之前销售量在增长，而后一天销售量减少，则称这一天为折点，反过来如果之前销售量减少而后一天销售量增长，也称这一天为折点。其他的天都不是折点。如下图中，第3天和第6天是折点。

　　给定n个整数a1, a2, …, an表示销售量，请计算出这些天总共有多少个折点。
　　为了减少歧义，我们给定的数据保证：在这n天中相邻两天的销售量总是不同的，即ai-1≠ai。注意，如果两天不相邻，销售量可能相同。
输入格式
　　输入的第一行包含一个整数n。
　　第二行包含n个整数，用空格分隔，分别表示a1, a2, …, an。
输出格式
　　输出一个整数，表示折点出现的数量。
样例输入
7
5 4 1 2 3 6 4
样例输出
2
评测用例规模与约定
　　所有评测用例满足：1 ≤ n ≤ 1000，每天的销售量是不超过10000的非负整数。
'''


d = eval(input())
s = [int(s) for s in input().split()]
num = 0
for i in range(1,d-1):
    if s[i]>s[i+1] and s[i]>s[i-1]:
        num+=1
    elif s[i]

16-04-2

'''
俄罗斯方块
问题描述
　　俄罗斯方块是俄罗斯人阿列克谢·帕基特诺夫发明的一款休闲游戏。
　　游戏在一个15行10列的方格图上进行，方格图上的每一个格子可能已经放置了方块，或者没有放置方块。每一轮，都会有一个新的由4个小方块组成的板块
从方格图的上方落下，玩家可以操作板块左右移动放到合适的位置，当板块中某一个方块的下边缘与方格图上的方块上边缘重合或者达到下边界时，
板块不再移动，如果此时方格图的某一行全放满了方块，则该行被消除并得分。
　　在这个问题中，你需要写一个程序来模拟板块下落，你不需要处理玩家的操作，也不需要处理消行和得分。
　　具体的，给定一个初始的方格图，以及一个板块的形状和它下落的初始位置，你要给出最终的方格图。
输入格式
　　输入的前15行包含初始的方格图，每行包含10个数字，相邻的数字用空格分隔。如果一个数字是0，表示对应的方格中没有方块，如果数字是1，
则表示初始的时候有方块。输入保证前4行中的数字都是0。
　　输入的第16至第19行包含新加入的板块的形状，每行包含4个数字，组成了板块图案，同样0表示没方块，1表示有方块。
输入保证板块的图案中正好包含4个方块，且4个方块是连在一起的（准确的说，4个方块是四连通的，即给定的板块是俄罗斯方块的标准板块）。
　　第20行包含一个1到7之间的整数，表示板块图案最左边开始的时候是在方格图的哪一列中。
注意，这里的板块图案指的是16至19行所输入的板块图案，如果板块图案的最左边一列全是0，则它的左边和实际所表示的板块的左边是不一致的（见样例）
输出格式
　　输出15行，每行10个数字，相邻的数字之间用一个空格分隔，表示板块下落后的方格图。注意，你不需要处理最终的消行。
样例输入
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0
1 1 1 0 0 0 1 1 1 1
0 0 0 0 1 0 0 0 0 0
0 0 0 0
0 1 1 1
0 0 0 1
0 0 0 0
3
样例输出
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0 0
1 1 1 1 1 1 1 1 1 1
0 0 0 0 1 1 0 0 0 0
'''


gra = []
for _ in range(15):
    gra.append(list(map(int, input().split())))
mat = []
for _ in range(4):
    mat.append(list(map(int, input().split())))
n = int(input())

# 俄罗斯方块处理
for i in range(4):  # 这里我把4*4填充成4*10，方便后面的处理
    mat[i] = [0] * (n - 1) + mat[i] + [0] * (7 - n)  # 10-(n-1)-4=7-n
for i in range(3, -1, -1):  # 去掉版块图案底部均为0的行
    if 1 not in mat[i]:
        mat.pop()
    else:
        break

# 下落过程
l = len(mat)
r = 15 - l
row = 0
for i in range(r + 1):
    line = []
    t = 0  # t是版块图案的行号
    for k in range(i, i + l):
        line = [gra[k][j] + mat[t][j] for j in range(10)]
        if 2 in line:  # 以行中是否有2来判断俄罗斯方块是否可用下落成功
            row = i - 1
            break
        t += 1
    if t != l:
        break
    if i == r:  # 如果熬到最后了，说明矩阵能触碰到方格图的底端
        row = i

t = 0
for k in range(row, row + l):
    gra[k] = [gra[k][j] + mat[t][j] for j in range(10)]
    t += 1

# 输出
for i in range(15):
    for j in range(10):
        print(gra[i][j], end=' ')
    print()

16-09-1

'''
最大波动
问题描述
　　小明正在利用股票的波动程度来研究股票。小明拿到了一只股票每天收盘时的价格，他想知道，这只股票连续几天的最大波动值是多少，即在这几天中某天收盘价格与前一天收盘价格之差的绝对值最大是多少。
输入格式
　　输入的第一行包含了一个整数n，表示小明拿到的收盘价格的连续天数。
　　第二行包含n个正整数，依次表示每天的收盘价格。
输出格式
　　输出一个整数，表示这只股票这n天中的最大波动值。
样例输入
6
2 5 5 7 3 5
样例输出
4
样例说明
　　第四天和第五天之间的波动最大，波动值为|3-7|=4。
评测用例规模与约定
　　对于所有评测用例，2 ≤ n ≤ 1000。股票每一天的价格为1到10000之间的整数。
'''


d = eval(input())
s = [int(s) for s in input().split()]
num = -1
for i in range(1,d):
    if abs(s[i]-s[i-1])>num:
        num = abs(s[i]-s[i-1])
print(num)

16-09-2

'''
火车购票
问题描述
　　请实现一个铁路购票系统的简单座位分配算法，来处理一节车厢的座位分配。
　　假设一节车厢有20排、每一排5个座位。为方便起见，
我们用1到100来给所有的座位编号，第一排是1到5号，第二排是6到10号，依次类推，第20排是96到100号。
　　购票时，一个人可能购一张或多张票，最多不超过5张。如果这几张票可以安排在同一排编号相邻的座位，
则应该安排在编号最小的相邻座位。否则应该安排在编号最小的几个空座位中（不考虑是否相邻）。
　　假设初始时车票全部未被购买，现在给了一些购票指令，请你处理这些指令。
输入格式
　　输入的第一行包含一个整数n，表示购票指令的数量。
　　第二行包含n个整数，每个整数p在1到5之间，表示要购入的票数，相邻的两个数之间使用一个空格分隔。
输出格式
　　输出n行，每行对应一条指令的处理结果。
　　对于购票指令p，输出p张车票的编号，按从小到大排序。
样例输入
4
2 5 4 2
样例输出
1 2
6 7 8 9 10
11 12 13 14
3 4
样例说明
　　1) 购2张票，得到座位1、2。
　　2) 购5张票，得到座位6至10。
　　3) 购4张票，得到座位11至14。
　　4) 购2张票，得到座位3、4。
评测用例规模与约定
　　对于所有评测用例，1 ≤ n ≤ 100，所有购票数量之和不超过100。
'''

import copy

d = eval(input())
piao = []
s = []
for i in range(1, 101):
    s.append(i)
    if i % 5 == 0:
        piao.append(s)
        s = []
hou = copy.deepcopy(piao)
s = [int(s) for s in input().split()]
for i in s:
    t = True
    hou = copy.deepcopy(piao)
    for j in range(20):

        if len(piao[j]) >= i:
            t = False
            for k in range(i):
                print(hou[j][k], end=" ")
                piao[j].remove(hou[j][k])
            print()
            break
    if t:
        d = i
        for j in range(20):
            if d - len(piao[j]) >= 0:
                l = len(piao[j])
                for k in range(l):
                    print(hou[j][k], end=" ")
                    piao[j].remove(hou[j][k])
                d = d - l
                if d == 0:
                    break
            else:
                d = len(piao[j]) - d
                for k in range(d):
                    print(hou[j][k], end=" ")
                    piao[j].remove(hou[j][k])
                print()
                break

16-12-1

'''
中间数
问题描述
　　在一个整数序列a1, a2, …, an中，如果存在某个数，大于它的整数数量等于小于它的整数数量，则称其为中间数。
在一个序列中，可能存在多个下标不相同的中间数，这些中间数的值是相同的。
　　给定一个整数序列，请找出这个整数序列的中间数的值。
输入格式
　　输入的第一行包含了一个整数n，表示整数序列中数的个数。
　　第二行包含n个正整数，依次表示a1, a2, …, an。
输出格式
　　如果约定序列的中间数存在，则输出中间数的值，否则输出-1表示不存在中间数。
样例输入
6
2 6 5 6 3 5
样例输出
5
样例说明
　　比5小的数有2个，比5大的数也有2个。
样例输入
4
3 4 6 7
样例输出
-1
样例说明
　　在序列中的4个数都不满足中间数的定义。
样例输入
5
3 4 6 6 7
样例输出
-1
样例说明
　　在序列中的5个数都不满足中间数的定义。
评测用例规模与约定
　　对于所有评测用例，1 ≤ n ≤ 1000，1 ≤ ai ≤ 1000。
'''


d = eval(input())
s = [int(s) for s in input().split()]
s.sort()
num = -1
for i in s:
    maxx, minn = 0, 0
    for j in s:
        if ij:
            maxx+=1
    if maxx==minn:
        num = i
print(num)

16-12-2

'''
工资计算
问题描述
　　小明的公司每个月给小明发工资，而小明拿到的工资为交完个人所得税之后的工资。
假设他一个月的税前工资（扣除五险一金后、未扣税前的工资）为S元，则他应交的个人所得税按如下公式计算：
　　1） 个人所得税起征点为3500元，若S不超过3500，则不交税，3500元以上的部分才计算个人所得税，令A=S-3500元；
　　2） A中不超过1500元的部分，税率3%；
　　3） A中超过1500元未超过4500元的部分，税率10%；
　　4） A中超过4500元未超过9000元的部分，税率20%；
　　5） A中超过9000元未超过35000元的部分，税率25%；
　　6） A中超过35000元未超过55000元的部分，税率30%；
　　7） A中超过55000元未超过80000元的部分，税率35%；
　　8） A中超过80000元的部分，税率45%；
　　例如，如果小明的税前工资为10000元，则A=10000-3500=6500元，
其中不超过1500元部分应缴税1500×3%=45元，超过1500元不超过4500元部分应缴税(4500-1500)×10%=300元，
超过4500元部分应缴税(6500-4500)×20%=400元。总共缴税745元，税后所得为9255元。
　　已知小明这个月税后所得为T元，请问他的税前工资S是多少元。
输入格式
　　输入的第一行包含一个整数T，表示小明的税后所得。所有评测数据保证小明的税前工资为一个整百的数。
输出格式
　　输出一个整数S，表示小明的税前工资。
样例输入
9255
样例输出
10000
评测用例规模与约定
　　对于所有评测用例，1 ≤ T ≤ 100000。
'''

t = eval(input())
tt = t//100*100
if t <=3500:
    print(t)
else:
    for i in range(tt+100,100001,100):
        p = i-3500
        num = 0
        if p<1500:
            num = p*0.03
        elif p<4500:
            num = (p-1500)*0.1+1500*0.03
        elif p<9000:
            num = (p-4500)*0.2+1500*0.03+3000*0.1
        elif p<35000:
            num = (p-9000)*0.25+1500*0.03+3000*0.1+4500*0.2
        elif p<55000:
            num = (p-35000)*0.3+1500*0.03+3000*0.1+4500*0.2+26000*0.25
        elif p<80000:
            num = (p-55000)*0.35+1500*0.03+3000*0.1+4500*0.2+26000*0.25+20000*0.3
        else:
            num = (p-80000)*0.45+1500*0.03+3000*0.1+4500*0.2+26000*0.25+20000*0.3+25000*0.35

        if t+num == i:
            print(i)
            break

17-03-1

'''
分蛋糕
问题描述
　　小明今天生日，他有n块蛋糕要分给朋友们吃，这n块蛋糕（编号为1到n）的重量分别为a1, a2, …, an。小明想分给每个朋友至少重量为k的蛋糕。
小明的朋友们已经排好队准备领蛋糕，对于每个朋友，小明总是先将自己手中编号最小的蛋糕分给他，当这个朋友所分得蛋糕的重量不到k时，
再继续将剩下的蛋糕中编号最小的给他，直到小明的蛋糕分完或者这个朋友分到的蛋糕的总重量大于等于k。
　　请问当小明的蛋糕分完时，总共有多少个朋友分到了蛋糕。
输入格式
　　输入的第一行包含了两个整数n, k，意义如上所述。
　　第二行包含n个正整数，依次表示a1, a2, …, an。
输出格式
　　输出一个整数，表示有多少个朋友分到了蛋糕。
样例输入
6 9
2 6 5 6 3 5
样例输出
3
样例说明
　　第一个朋友分到了前3块蛋糕，第二个朋友分到了第4、5块蛋糕，第三个朋友分到了最后一块蛋糕。
评测用例规模与约定
　　对于所有评测用例，1 ≤ n ≤ 1000，1 ≤ k ≤ 10000，1 ≤ ai ≤ 1000。
'''


n,k = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
temp = 0
num = 1
for i in a:
    if temp>=k:
        num+=1
        temp=0
    temp+=i
print(num)
# print(n,k)
# print(a)

17-03-2

'''
学生排队
问题描述
　　体育老师小明要将自己班上的学生按顺序排队。他首先让学生按学号从小到大的顺序排成一排，
学号小的排在前面，然后进行多次调整。一次调整小明可能让一位同学出队，向前或者向后移动一段距离后再插入队列。
　　例如，下面给出了一组移动的例子，例子中学生的人数为8人。
　　0）初始队列中学生的学号依次为1, 2, 3, 4, 5, 6, 7, 8；
　　1）第一次调整，命令为“3号同学向后移动2”，表示3号同学出队，向后移动2名同学的距离，再插入到队列中，新队列中学生的学号依次为1, 2, 4, 5, 3, 6, 7, 8；
　　2）第二次调整，命令为“8号同学向前移动3”，表示8号同学出队，向前移动3名同学的距离，再插入到队列中，新队列中学生的学号依次为1, 2, 4, 5, 8, 3, 6, 7；
　　3）第三次调整，命令为“3号同学向前移动2”，表示3号同学出队，向前移动2名同学的距离，再插入到队列中，新队列中学生的学号依次为1, 2, 4, 3, 5, 8, 6, 7。
　　小明记录了所有调整的过程，请问，最终从前向后所有学生的学号依次是多少？
　　请特别注意，上述移动过程中所涉及的号码指的是学号，而不是在队伍中的位置。在向后移动时，移动的距离不超过对应同学后面的人数，
如果向后移动的距离正好等于对应同学后面的人数则该同学会移动到队列的最后面。在向前移动时，移动的距离不超过对应同学前面的人数，
如果向前移动的距离正好等于对应同学前面的人数则该同学会移动到队列的最前面。
输入格式
　　输入的第一行包含一个整数n，表示学生的数量，学生的学号由1到n编号。
　　第二行包含一个整数m，表示调整的次数。
　　接下来m行，每行两个整数p, q，如果q为正，表示学号为p的同学向后移动q，如果q为负，表示学号为p的同学向前移动-q。
输出格式
　　输出一行，包含n个整数，相邻两个整数之间由一个空格分隔，表示最终从前向后所有学生的学号。
样例输入
8
3
3 2
8 -3
3 -2
样例输出
1 2 4 3 5 8 6 7
评测用例规模与约定
　　对于所有评测用例，1 ≤ n ≤ 1000，1 ≤ m ≤ 1000，所有移动均合法。
'''

n = eval(input())
dui = [s for s in range(1,n+1)]
m = eval(input())
for i in range(m):
    s=[int(s) for s in input().split()]
    wei = dui.index(s[0])
    if s[1]>0:
        temp = dui[wei]
        for j in range(s[1]):
            dui[wei+j] = dui[wei+j+1]
        dui[wei+s[1]] = temp
    elif s[1]<0:
        temp = dui[wei]
        for j in range(0,s[1],-1):
            dui[wei+j] = dui[wei+j-1]
        dui[wei+s[1]] = temp
for i in dui:
    print(i,end=" ")

17-09-1

'''
打酱油
问题描述
　　小明带着N元钱去买酱油。酱油10块钱一瓶，商家进行促销，每买3瓶送1瓶，或者每买5瓶送2瓶。请问小明最多可以得到多少瓶酱油。
输入格式
　　输入的第一行包含一个整数N，表示小明可用于买酱油的钱数。N是10的整数倍，N不超过300。
输出格式
　　输出一个整数，表示小明最多可以得到多少瓶酱油。
样例输入
40
样例输出
5
样例说明
　　把40元分成30元和10元，分别买3瓶和1瓶，其中3瓶送1瓶，共得到5瓶。
样例输入
80
样例输出
11
样例说明
　　把80元分成30元和50元，分别买3瓶和5瓶，其中3瓶送1瓶，5瓶送2瓶，共得到11瓶。
'''


n = eval(input())
num = 0
a1 = int(n/10)
b1 = int(n/30)
c1 = int(n/50)
if b1 == 0:
    num = a1
elif c1 == 0:
    for a in range(a1+1):
        for b in range(b1+1):
            if (10*a+30*b)<=n:
                if num < a+4*b:
                    num = a+4*b
else:
    for a in range(a1+1):
        for b in range(b1+1):
            for c in range(c1+1):
                if (10 * a + 30 * b + 50 * c) <= n:
                    if num 

17-09-2

'''
公共钥匙盒

'''



#把编号为key_no的钥匙放回公共钥匙盒lockkeys
def key_in(lockkeys, key_no):
    for i in range(len(lockkeys)):
        if lockkeys[i] == NOT_HERE:
            lockkeys[i] = key_no
            break
    return lockkeys
#从公共钥匙盒lockkeys中取走编号为key_no的钥匙
def key_out(lockkeys, key_no):
    for i in range(len(lockkeys)):
        if lockkeys[i] == key_no:
            lockkeys[i] = NOT_HERE
            break
    return lockkeys

def print_lockkeys(lockkeys):
    for k in lockkeys:
        print(k, end=' ')

num_key, num_line = input().split()
num_key = int(num_key)
num_line = int(num_line)
key_back_go_list = []  #取/还钥匙动作序列
for i in range(num_line):
    lockkey, start, duration = input().split()
    lockkey = int(lockkey)
    start = int(start)
    duration = int(duration)
    key_back_go_list.append((lockkey, start, 'out'))
    key_back_go_list.append((lockkey, start + duration, 'in'))  #取/还钥匙动作序列的元素：（钥匙号，发生时刻，动作类别）
# for item in key_back_go_list:
#     print(item[0], item[1], item[2])
#动作序列排序
key_back_go_list.sort(key=lambda item: item[0])  #如果有多位老师还钥匙，则他们按钥匙编号从小到大的顺序还。
key_back_go_list.sort(key=lambda item: item[2])  #如果同一时刻既有老师还钥匙又有老师取钥匙，则老师们会先将钥匙全还回去再取出。
key_back_go_list.sort(key=lambda item: item[1])  #按时刻从早到晚排序
# for item in key_back_go_list:
#     print(item[0], item[1], item[2])

lockkeys = list(range(1, num_key + 1))
NOT_HERE = 0
for item in key_back_go_list:
    if item[2] == 'in':
        lockkeys = key_in(lockkeys, item[0])  #取钥匙，改变钥匙盒的状态
        # print_lockkeys(lockkeys)
    else:
        lockkeys = key_out(lockkeys, item[0]) #还钥匙，改变钥匙盒的状态
        # print_lockkeys(lockkeys)
    # print()

print_lockkeys(lockkeys)

17-12-1

'''
最小差值
问题描述
　　给定n个数，请找出其中相差（差的绝对值）最小的两个数，输出它们的差值的绝对值。
输入格式
　　输入第一行包含一个整数n。
　　第二行包含n个正整数，相邻整数之间使用一个空格分隔。
输出格式
　　输出一个整数，表示答案。
样例输入
5
1 5 4 8 20
样例输出
1
样例说明
　　相差最小的两个数是5和4，它们之间的差值是1。
样例输入
5
9 3 6 1 3
样例输出
0
样例说明
　　有两个相同的数3，它们之间的差值是0.
数据规模和约定
　　对于所有评测用例，2 ≤ n ≤ 1000，每个给定的整数都是不超过10000的正整数。
'''


n = eval(input())
s = [int(s) for s in input().split()]
s.sort()
num = s[1]-s[0]
for i in range(2,n):
    if num > s[i]-s[i-1]:
        num =s[i] - s[i - 1]
print(num)


# print(a)

17-12-2

'''
游戏
'''

n,k=[int(s) for s in input().split()]
peng = [s for s in range(1,n+1)]
num = 0
while len(peng)>1:
    num+=1
    i = peng.pop(0)
    if num%k!=0 and num%10!=k:
        peng.append(i)
print(peng[0])

18-03-1

'''
跳一跳
问题描述
　　近来，跳一跳这款小游戏风靡全国，受到不少玩家的喜爱。
　　简化后的跳一跳规则如下：玩家每次从当前方块跳到下一个方块，如果没有跳到下一个方块上则游戏结束。
　　如果跳到了方块上，但没有跳到方块的中心则获得1分；跳到方块中心时，若上一次的得分为1分或这是本局游戏的第一次跳跃则此次得分为2分，
否则此次得分比上一次得分多两分（即连续跳到方块中心时，总得分将+2，+4，+6，+8...）。
　　现在给出一个人跳一跳的全过程，请你求出他本局游戏的得分（按照题目描述的规则）。
输入格式
　　输入包含多个数字，用空格分隔，每个数字都是1，2，0之一，1表示此次跳跃跳到了方块上但是没有跳到中心，
2表示此次跳跃跳到了方块上并且跳到了方块中心，0表示此次跳跃没有跳到方块上（此时游戏结束）。
输出格式
　　输出一个整数，为本局游戏的得分（在本题的规则下）。
样例输入
1 1 2 2 2 1 1 2 2 0
样例输出
22
数据规模和约定
　　对于所有评测用例，输入的数字不超过30个，保证0正好出现一次且为最后一个数字。
'''

s = [int(s) for s in input().split()]
temp = -1
count = 0
for i in s:
    if (temp == 1 or temp == -1) and i==2:
        temp = 2
        count += temp
    elif temp%2==0 and i==2:
        temp += 2
        count += temp
    elif i == 1:
        temp = 1
        count += temp
    elif i == 0:
        break

print(count)

18-03-2

'''
碰撞的小球
'''

n,L,t=map(int,input().split())
num=list(map(int,input().split()))
dir=[1]*n
for i in range(t):
    for j in range(n):
        if num[j]==L or num[j]==0:
            dir[j]=-dir[j]
        if num.count(num[j])!=1:
            dir[j]=-dir[j]
    num=[i+j for i,j in zip(num,dir)]
    #num=list(map(lambda i,j:i+j ,num,dir))
for i in num:
    print(i,end=' ')

18-09-1

'''
卖菜
问题描述
　　在一条街上有n个卖菜的商店，按1至n的顺序排成一排，这些商店都卖一种蔬菜。
　　第一天，每个商店都自己定了一个价格。店主们希望自己的菜价和其他商店的一致，第二天，每一家商店都会根据他自己和相邻商店的价格调整自己的价格。具体的，每家商店都会将第二天的菜价设置为自己和相邻商店第一天菜价的平均值（用去尾法取整）。
　　注意，编号为1的商店只有一个相邻的商店2，编号为n的商店只有一个相邻的商店n-1，其他编号为i的商店有两个相邻的商店i-1和i+1。
　　给定第一天各个商店的菜价，请计算第二天每个商店的菜价。
输入格式
　　输入的第一行包含一个整数n，表示商店的数量。
　　第二行包含n个整数，依次表示每个商店第一天的菜价。
输出格式
　　输出一行，包含n个正整数，依次表示每个商店第二天的菜价。
样例输入
8
4 1 3 1 6 5 17 9
样例输出
2 2 1 3 4 9 10 13
数据规模和约定
　　对于所有评测用例，2 ≤ n ≤ 1000，第一天每个商店的菜价为不超过10000的正整数。
'''

n = eval(input())
s = [int(s) for s in input().split()]
er = []
for i in range(n):
    if i==0:
        temp = int((s[i]+s[i+1])/2)
        er.append(temp)
    elif i == n-1:
        temp = int((s[i] + s[i - 1]) / 2)
        er.append(temp)
    else:
        temp = int((s[i] + s[i + 1]+s[i - 1]) / 3)
        er.append(temp)
for i in er:
    print(i,end=" ")
#
# print(count)

18-09-2

'''
买菜
'''

n = eval(input())
k=[]
w=[]
time = [0]*1000001
for i in range(n):
    s = [int(s) for s in input().split()]
    for j in range(s[0], s[1]):
        time[j]+=1
for i in range(n):
    s = [int(s) for s in input().split()]
    for j in range(s[0], s[1]):
        time[j]+=1
print(time.count(2))

18-12-1

'''
小明上学
题目背景
　　小明是汉东省政法大学附属中学的一名学生，他每天都要骑自行车往返于家和学校。为了能尽可能充足地睡眠，他希望能够预计自己上学所需要的时间。
他上学需要经过数段道路，相邻两段道路之间设有至多一盏红绿灯。
　　京州市的红绿灯是这样工作的：每盏红绿灯有红、黄、绿三盏灯和一个能够显示倒计时的显示牌。
假设红绿灯被设定为红灯 r 秒，黄灯 y 秒，绿灯 g 秒，那么从 0 时刻起，[0,r) 秒内亮红灯，车辆不许通过；
[r, r+g) 秒内亮绿灯，车辆允许通过；[r+g, r+g+y) 秒内亮黄灯，车辆不许通过，然后依次循环。
倒计时的显示牌上显示的数字 l（l > 0）是指距离下一次信号灯变化的秒数。

问题描述
　　一次上学的路上，小明记录下了经过每段路的时间，和各个红绿灯在小明到达路口时的颜色和倒计时秒数。希望你帮忙计算此次小明上学所用的时间。
输入格式
　　输入的第一行包含空格分隔的三个正整数 r、y、g，表示红绿灯的设置。这三个数均不超过 106。
　　输入的第二行包含一个正整数 n（n ≤ 100），表示小明总共经过的道路段数和看到的红绿灯数目。
　　接下来的 n 行，每行包含空格分隔的两个整数 k、t。k=0 表示经过了一段道路，耗时 t 秒，
此处 t 不超过 106；k=1、2、3 时，分别表示看到了一个红灯、黄灯、绿灯，且倒计时显示牌上显示的数字是 t，此处 t 分别不会超过 r、y、g。
输出格式
　　输出一个数字，表示此次小明上学所用的时间。
样例输入
30 3 30
8
0 10
1 5
0 11
2 2
0 6
0 3
3 10
0 3
样例输出
70
样例说明
　　小明先经过第一段道路，用时 10 秒，
然后等待 5 秒的红灯，再经过第二段道路，用时 11 秒，然后等待 2 秒的黄灯和 30 秒的红灯，再经过第三段、第四段道路，分别用时6、3秒，然后通过绿灯，
再经过最后一段道路，用时 3 秒。共计 10 + 5 + 11 + 2 + 30 + 6 + 3 + 3=70 秒。
评测用例规模与约定
　　测试点 1, 2 中不存在任何信号灯。
　　测试点 3, 4 中所有的信号灯在被观察时均为绿灯。
　　测试点 5, 6 中所有的信号灯在被观察时均为红灯。
　　测试点 7, 8 中所有的信号灯在被观察时均为黄灯。
　　测试点 9, 10 中将出现各种可能的情况。
'''


r,y,g = [int(s) for s in input().split()]
n = eval(input())
time = 0
for i in range(n):
    s = [int(s) for s in input().split()]
    if s[0]==0:
        time += s[1]
    elif s[0]==1:
        time += s[1]
    elif s[0]==2:
        time += s[1]+r

print(time)


# print(count)

18-12-2

'''
小明放学
'''


def updatetime(time,k,t):
    if k == 0:
        return t
    elif k == 1:  # 红
        if time > t :
            return updatetime(time-t,3,g)
        else:
            return  t-time
    elif k == 2:  # 黄
        if time > t:
            return updatetime(time - t, 1, r)
        else:
            return t - time + r
    elif k == 3:  # 绿
        if time > t:
            return updatetime(time - t, 2, y)
        else:
            return 0


r,y,g = [int(s) for s in input().split()]
n = eval(input())
time = 0
for i in range(n):
    k,t = [int(s) for s in input().split()]
    time += updatetime(time%(r+y+g),k,t)

print(time)

19-03-1

'''
小中大
'''


n = eval(input())
a = [int(s) for s in input().split()]
a.sort()
m = []
if n%2==0:
    m.append(a[0])
    m.append(a[-1])
    temp = (a[int(n/2)]+a[int(n/2 - 1)])/2.0
    if temp%1>0.0:
        m.append(temp)
    else:
        m.append(int(temp))
else:
    m.append(a[0])
    m.append(a[-1])
    m.append((a[n // 2]))
m.sort(reverse=True)
for i in m:
    print(i,end=" ")

19-03-2

'''
二十四点

'''


def suanshu(a, f, b):
    if f == "x":
        return int(a) * int(b)
    elif f == "/":
        return int(a) // int(b)
    elif f == "+":
        return int(a) + int(b)
    elif f == "-":
        return int(a) - int(b)


n = eval(input())
for i in range(n):
    s = list(input())
    while len(s) > 1:
        if "x" in s and "/" in s:
            c1 = s.index("x")
            c2 = s.index("/")
            c = c1 if c1 < c2 else c2
            a = s.pop(c - 1)
            f = s.pop(c - 1)
            b = s.pop(c - 1)
            zhi = suanshu(a, f, b)
            s.insert(c - 1,zhi)
        elif "x" in s:
            c = s.index("x")
            a = s.pop(c - 1)
            f = s.pop(c - 1)
            b = s.pop(c - 1)
            zhi = suanshu(a, f, b)
            s.insert(c - 1,zhi)
        elif "/" in s:
            c = s.index("/")
            a = s.pop(c - 1)
            f = s.pop(c - 1)
            b = s.pop(c - 1)
            zhi = suanshu(a, f, b)
            s.insert( c - 1,zhi)
        else:
            a = s.pop(0)
            f = s.pop(0)
            b = s.pop(0)
            zhi = suanshu(a, f, b)
            s.insert(0,zhi)
    if int(s[0]) == 24:
        print("Yes")
    else:
        print("No")

# n = int(input())
#
# for i in range(n):
#     str = input().replace('x', '*').replace('/', '//')
#     print("Yes" if eval(str) == 24 else "No")

19-09-1

'''
小明种苹果

'''



n,m = [int(s) for s in input().split()]
shu = []
for num in range(n):
    s = [int(s) for s in input().split()]
    temp = 0
    for i in range(1,m+1):
        temp+=s[i]
    summ = s[0]+temp
    s.append(summ)
    s.append(abs(temp))
    s.append(num+1)
    shu.append(s)

t,k,p=0,-1,-1
for i in shu:
    t+=i[-3]
    if k

19-09-2

'''
小明种苹果

'''

n = eval(input())
t,d = 0,0
e=[0]*n
for i in range(n):
    s = [int(s) for s in input().split()]
    num = s[1]
    for j in range(2,s[0]+1):
        if s[j]<=0:
           num+=s[j]
        else:
            if num > s[j]:
                num = s[j]
                if e[i]==0:
                    d+=1
                    e[i]=1
    t+=num
enum = 0
e = e+e[0:2]

if e.count(1)>2:
    for i in range(1,len(e)-1):
        if e[i]==e[i-1]==e[i+1]==1:
            enum+=1

print(t,d,enum)

19-12-1

'''
报数

'''


n = eval(input())
ren=[0,0,0,0]
num = 1
i = 1
while i <= n :
    if num%7==0 or ('7' in str(num)):
        ren[num%4] += 1
        i-=1
    num+=1
    i+=1
print(ren[1])
print(ren[2])
print(ren[3])
print(ren[0])

19-12-2

'''
回收站选址

'''

n = eval(input())
fen = [0]*5
dian = []
for i in range(n):
    s = [int(s) for s in input().split()]
    dian.append(s)
if len(dian)>4:
    for i in dian:
        x,y = i
        if ([x,y+1] in dian) and ([x,y-1] in dian) and ([x+1,y] in dian) and ([x-1,y] in dian):
            num = 0
            if [x+1,y+1] in dian:
                num+=1
            if [x+1,y-1] in dian:
                num+=1
            if [x-1,y+1] in dian:
                num+=1
            if [x-1,y-1] in dian:
                num+=1
            fen[num]+=1

for i in fen:
    print(i)

20-06-1

'''
线性分类器
'''

n,m = [int(s) for s in input().split()]
dian = []
for i in range(n):
    s = [s for s in input().split()]
    dian.append(s)
xian = []
for i in range(m):
    s = [int(s) for s in input().split()]
    xian.append(s)
jie = []

for i in xian:
    zuo = set()
    you = set()
    for j in dian:
        if i[0]+int(j[0])*i[1]+int(j[1])*i[2]>0:
            zuo.add(j[-1])
        elif i[0]+int(j[0])*i[1]+int(j[1])*i[2]<0:
            you.add(j[-1])
    if len(you)== 1 and len(zuo)==1:
        jie.append("Yes")
    else:
        jie.append("No")
for i in jie:
    print(i)

20-06-2

'''
稀疏向量
'''


n,a,b=[int(s) for s in input().split()]

av = {}
for i in range(a):
    u,v = [int(s) for s in input().split()]
    av[u]=v

zhi = 0
for i in range(b):
    u,v = [int(s) for s in input().split()]
    if u in av.keys():
        zhi += av[u]*v
print(zhi)

20-09-1

'''
称检测点查询

'''

import math
n,x,y = [int(s) for s in input().split()]
num = 1
d = 1000
dict1 = {}
for i in range(n):
    s = [int(s) for s in input().split()]
    zhi = math.sqrt(pow((x-s[0]),2)+pow((y-s[1]),2))
    dict1[num] = zhi
    num+=1
items = list(dict1.items())
items.sort(key=lambda x: x[1], reverse=False)
for i in range(3):
    a,b = items[i]
    print(a)

20-09-2

'''
风险人群筛查

'''

n, k, t, xl, yd, xr, yu = [int(s) for s in input().split()]

# 记录经过的人的数量
Pass = 0
# 记录逗留的人的数量
Stay = 0


def sites(x, y):
    if x >= xl and y >= yd and x <= xr and y <= yu:
        return True
    else:
        return False


for i in range(n):
    s = [int(s) for s in input().split()]
    t = False
    count = 0
    for j in range(0, len(s) - 1, 2):
        if sites(s[j], s[j + 1]):
            t = True
            count += 1
            if count >= k:
                Stay += 1
                break
        else:
            count = 0
    if t:
        Pass += 1
print(Pass)
print(Stay)

20-12-1

'''
期末预测之安全指数
'''

n = eval(input())
summ = 0
for i in range(n):
    score,w = [int(s) for s in input().split()]
    summ += score * w
print(max(0,summ))

20-12-2

listArray = []      # 存放成绩与挂科的成对数据
ySet = set()        # 集合用于去重
n = int(input())

sum = [0 for i in range(n + 1)]
#前缀和数组（为什么下标范围是[1, n]?
#答：习惯计数法。表示前n项的和
#tips: 初始化下标0对应的值为0，方便之后累加计算sum[1] = sum[0] + 【第一项数据的成绩】

# 存放数据
for i in range(n):
    y, flag = map(int, input().split())
    listArray.append((y, flag))

# 排序。按照成绩（二维数组listArray中每个一维数组的第一个元素）排序
listArray = sorted(listArray, key = lambda x : x[0])

# 计算前缀和
for i in range(1, n + 1):
    sum[i] = sum[i - 1] + listArray[i - 1][1]

# 设置临时变量
maxMatch = -1   # 最大匹配数
maxSuitable = -1    # 最合适的成绩
for i, pair in enumerate(listArray):
    if (pair[0] in ySet):    # 集合去重。如果成绩重复则不讨论这对数据
        continue
    ySet.add(pair[0])       # 将不重复的成绩加入集合
    one = sum[n] - sum[i]
    zero = i - sum[i]
    total = zero + one
    if (total  >=  maxMatch):
        maxMatch = total
        maxSuitable = pair[0]

print(maxSuitable)

21-04-1

'''
灰度直方图
'''
# n,m,l = [int(s) for s in input().split()]
# h = [0]*l
# xiang = []
# for i in range(n):
#     s = [int(s) for s in input().split()]
#     for j in range(l):
#        h[j]+= s.count(j)
# for i in h:
#     print(i,end=" ")

# 输入矩阵大小n,m和灰度范围L
n,m,L = list(map(int,input().split()))
# 初始化灰度统计列表
statistics = [0 for i in range(L)]
# 循环n次
for i in range(n):
    # 按行输入数据
    grayscales = list(map(int,input().split()))
    # 遍历每行灰度元素
    for grayscale in grayscales:
        # 灰度值对应位置统计数字自增
        statistics[grayscale] += 1
# 输出
for i in range(L):
    print(statistics[i],end=' ')

21-04-2

'''
灰度直方图
'''

n,L,r,t = list(map(int,input().split()))
nums = []
for _ in range(n):
    nums.append([int(i) for i in input().split()])
# 1.计算前缀和
s = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
    for j in range(1, n + 1):
        s[i][j] = nums[i - 1][j - 1] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1]
count = 0
# 2.计算区域和
for i in range(1, n + 1):
    for j in range(1, n + 1):
        x1=max(1,i - r)
        y1=max(1,j - r)
        x2=min(i + r,n)
        y2=min(j + r,n)
        nnn = s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1]
        g = (x2-x1+1)*(y2-y1+1)
        if nnn/g <= t:
            count+=1
print(count)