python练习7——PTA

7-1 jmu-python-异常-学生成绩处理专业版 (25 分)

小明在帮助老师统计成绩，老师给他的是一组数据。数据的第1行代表学生数n，后面
的n行代表每个学生的成绩。成绩是整数类型。小明编写了一个程序，该程序可以批量
处理数据，统计所有学生的平均分。当数据没有任何错误时，提示’All OK’，当数据有
一些错误(某行是浮点数、某行是非整数字符)时，可以提示哪些数据出错，并最后提示
第几行出错，出错的原因，共出错多少行。对于另一些小错误，如某行虽然是整数，但
是左右有多余的空格，可以将空格去除掉进行正常统计。

在最后输出：
共处理多少行数据，几行正确，几行错误，平均成绩(保留两位小数)。

进阶要求：
有可能碰到要求输入n行，后面的数据却小于n行。要求处理这种情况。碰到这种情况。
输出end of files，并统计现有行数。见样例3

输入格式:
第1行为n
接下来输入<=n行数据进行测试

输出格式:
见样例输出。输出错误原因的时候，需要将整行输出（如果该行有左右空格，需要将左右空格也输出）

输入样例1:
3
1
2
3
结尾无空行
输出样例1:
Total: 3
OK: 3
Error: 0
avg grade = 2.00
结尾无空行
输入样例2:
5
1
2
a
b 5
3
结尾无空行
输出样例2:
line 3 error for input " a "
line 4 error for input " b 5"
Total: 5
OK: 3
Error: 2
avg grade = 2.00
结尾无空行
输入样例3:
5
a
2
3
结尾无空行
输出样例3:
line 1 error for input " a"
end of files
Total: 3
OK: 2
Error: 1
avg grade = 2.50
结尾无空行
提示：对于样例3，如果是在IDLE中进行测试，可在输入最后一行并回车后，按’Ctrl+D’结束输入。

此题代码后补

7-2 jmu-分段函数l (20 分)

本题目要求计算以下分段函数的值（x为从键盘输入的一个任意实数）：

1.png

如果输入非数字，则输出“Input Error!”

输入格式:
在一行中输入一个实数x。

输出格式:
在一行中按”y=result”的格式输出，其中result保留两位小数。

输入样例:
-2
结尾无空行
输出样例:
在这里给出相应的输出。例如：

y=3.00
结尾无空行

try:
        x=float(input())
        if x<=-2:
            ans=(-2*x)-1
        elif x>-2 and x<=1:
            ans=3
        elif x>1:
            ans=2*x+1
        print("y={:.2f}".format(ans))
        exit(0)
except Exception as result:#这个加域不加，以及break在try里是否能用
        print("Input Error!")

7-3 jmu-python-简单计算器 (20 分)

输入一个表达式字符串，计算其结果

输入格式:
行1：输入字符串数目
下面分别输入要计算的表达式
输出格式:
输出计算结果，结果保留2位小数。对于异常数据能输出相应异常信息。

输入样例1:
4
1+1
56-23
5/3
5*3.5
结尾无空行
输出样例1:
2.00
33.00
1.67
17.50
结尾无空行
输入样例2:
3
ab+23
2/0
23+36f
结尾无空行
输出样例2:
NameError
ZeroDivisionError
SyntaxError
结尾无空行

times = int(input())
for _ in range(times):
    exp = input()
    try:
        result = eval(exp)
    except NameError:
        print("NameError")
    except ZeroDivisionError:
        print("ZeroDivisionError")
    except SyntaxError:
        print("SyntaxError")
    else:
        print("%.2f"%result)

7-4 JMU-Python-分段函数 (20 分)

本题目要求根据以下分段函数的定义，计算输入的x对应的y值，输出结果保留两位小数；如果输入的x是非数值型数据，输出’Input Error’。注意：使用math库

Snap5.bmp

输入格式:
在一行中输入x的值。

输出格式:
按“f(x) = result”的格式输出，其中x与result都保留两位小数，注意’='两边有空格。

如果输入的x是非数值型数据，输出：Input Error

输入样例1:
1.5
结尾无空行
输出样例1:
f(1.50) = 4.55
结尾无空行
输入样例2:
-4
结尾无空行
输出样例2:
f(-4.00) = 0.00
结尾无空行
输入样例3:
abc
结尾无空行
输出样例3:
Input Error
结尾无空行

import math as m
def demo1(x):
    if x > 0:
        y = m.cos(x) + m.exp(x)
    elif x==0:
        print("0.00")
    else:
        y = 0
    print("f(%.2f) = %.2f" %(x,y))
try:
    x = float(input())
    demo1(x)
except Exception as result:
    print("Input Error")#居然是这个！感叹号，我要注意细节啊！

7-5 JMU-Python-分段函数 (20 分)

本题目要求根据以下分段函数的定义，计算输入的x对应的y值，输出结果保留两位小数；如果输入的x是非数值型数据，输出’Input Error’。注意：使用math库

Snap6.bmp

输入格式:
在一行中输入x的值。

输出格式:
按“f(x) = result”的格式输出，其中x与result都保留两位小数，注意’='两边有空格。

如果输入的x是非数值型数据，输出：Input Error

输入样例1:
4
结尾无空行
输出样例1:
f(4.00) = 3.39
结尾无空行
输入样例2:
-6
结尾无空行
输出样例2:
f(-6.00) = 0.00
结尾无空行
输入样例3:
x
结尾无空行
输出样例3:
Input Error
结尾无空行

import math as m
try:
    x=float(input())
    if x<=0:
        ans=0
    else:
        ans=m.log(x)+m.sqrt(x)
    print("f({:.2f}) = {:.2f}".format(x,ans))
except Exception as result:
    print("Input Error")

7-6 jmu-python-查成绩 (10 分)

从键盘输入一个学生所有课程的成绩，输入格式为”课程名:成绩“，每门课占一行，以空行结束。随后提示”请输入要查询的课程：“，用户从键盘输入课程名，查询并输出该课程的成绩，要求进行异常处理，对不存在的课程进行捕捉处理。

输入格式:
输入学生所有课程的成绩，每门课占一行，格式为”课程名:成绩“，以空行结束 在提示后输入课程名

输出格式:
如果课程存在，直接输出成绩，否则提示”没有该门课程“

输入样例1:
数学:96
英语:82
计算机:76
思政:90

计算机
结尾无空行
输出样例1:
请输入要查询的课程：
76
结尾无空行
输入样例2:
数学:96
英语:82
计算机:76
思政:90

数学a
结尾无空行
输出样例2:
请输入要查询的课程：
没有该门课程
结尾无空行

zd={
    
    }
while True:
    try:
        tmp=input()
        if len(tmp)==1:
            break
        m,n=map(str,tmp.split(":"))
        zd[m]=n
    except:
        break
ask=input("请输入要查询的课程：\n")
if ask in zd.keys():
    print(zd[ask])  
else:
    print("没有该门课程")
        

7-7 竞赛排名 (10 分)

某循环赛的比赛规则是胜者得3分，和者得1分，败者不得分。请根据各人总得分从高到低进行排名。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试先输入一个整数n（2≤n≤100），表示参赛人数，然后输入n*(n-1)/2行，每行一个比赛结果。每行比赛结果由A、B、f构成，A和B为参赛人名（不含空格），f=1表示A胜B，f=0表示A与B打和。由于总是将胜者排在前面，所以不存在A败于B的情况。

输出格式:
对于每组测试，按名次分行输出，名次与名字之间以一个空格间隔，并列名次的名字在同一行输出，按字典序以一个空格隔开。

输入样例:
2
3
Jack Smith 0
Smith Bob 1
Jack Bob 1
6
a b 1
c a 0
a d 0
a e 1
f a 1
b c 1
d b 0
e b 0
f b 0
c d 1
c e 1
c f 1
d e 0
f d 0
e f 0
输出样例:
1 Jack Smith
3 Bob
1 c
2 a
3 b f
5 d
6 e
出处:
ZJUTOJ 1330

t=int(input())
for T in range(t):
    n=int(input())
    A=set()
    f=[]
    defen={
    
    }
    num=(n*(n-1))/2
    num=int(num)
    for N in range(num):
        s=map(str,input().split())
        s=list(s)
        A.add(s[0])
        A.add(s[1])
        f.append(int(s[2]))
        if int(s[2])==1:
            if s[0] in defen.keys():
                defen[s[0]]+=3
            else:
                defen[s[0]]=3
        elif int(s[2])==0:
            if s[0] in defen.keys():
                defen[s[0]]+=1
            else:
                defen[s[0]]=1
            if s[1] in defen.keys():
                defen[s[1]]+=1
            else:
                defen[s[1]]=1
#     print(A)
    A=list(A)
    A.sort()
    # print("我要的")
#     print(A)
    num=len(A)
    ans=[]
    for N in range(num):
        if A[N] not in defen.keys():
            defen[A[N]]=0
#     print(ans)
    defent=sorted(defen.items(),key=lambda d:(-d[1],d[0]))
#     print(defent)
    ans={
    
    }
    dexm=0
    indexn=0
    for i in range(n):
        indexn=i+1
        tmp = defent[i][0]
#         print("tmp来了"+tmp,dexm)
        if i>=1 and defent[i][1] == defent[i - 1][1] and defent[i][1]!=0:#一样的分数，要使排名相同

                ans[dexm].append(tmp)
#                 print(tmp,dexm)
        else:#出现不一样的分数
                dexm=indexn
#                 print(str(tmp),indexn)
                tmp=str(tmp)
                ans[indexn]=[]
                ans[indexn].append(tmp)
                # 记录那个变化的排序数

#         print(ans)
    for key,value in ans.items():
        print("{}".format(key),end="")
        for i in value:
            print(" {}".format(i),end="")
        print()

7-8 进步排行榜 (10 分)

假设每个学生信息包括“用户名”、“进步总数”和“解题总数”。解题进步排行榜中，按“进步总数”及“解题总数”生成排行榜。要求先输入n个学生的信息；然后按“进步总数”降序排列；若“进步总数”相同，则按“解题总数”降序排列；若“进步总数”和“解题总数”都相同，则排名相同，但输出信息时按“用户名”升序排列。

输入格式:
首先输入一个整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据先输入一个正整数n（1 < n < 50），表示学生总数。然后输入n行，每行包括一个不含空格的字符串s（不超过8位）和2个正整数d和t，分别表示用户名、进步总数和解题总数。

输出格式:
对于每组测试，输出最终排名。每行一个学生的信息，分别是排名、用户名、进步总数和解题总数。每行的各个数据之间留一个空格。注意，进步总数和解题总数都相同的学生其排名也相同。

输入样例:
2
6
usx15131 21 124
usx15101 27 191
usx15113 31 124
usx15136 18 199
usx15117 27 251
usx15118 21 124
10
usx15131 21 124
usx15101 27 191
usx15107 24 154
usx15113 31 124
usx15117 25 251
usx15118 21 124
usx15119 22 117
usx15121 43 214
usx15128 21 124
usx15136 28 199
输出样例:
1 usx15113 31 124
2 usx15117 27 251
3 usx15101 27 191
4 usx15118 21 124
4 usx15131 21 124
6 usx15136 18 199
1 usx15121 43 214
2 usx15113 31 124
3 usx15136 28 199
4 usx15101 27 191
5 usx15117 25 251
6 usx15107 24 154
7 usx15119 22 117
8 usx15118 21 124
8 usx15128 21 124
8 usx15131 21 124

#会用那个多个比较规则就好写多了
t=int(input())
for T in range(t):
    n=int(input())
    name=[]
    d=[]
    t=[]
    zd={
    
    }
    for N in range(n):
        s=map(str,input().split())
        s=list(s)
        # print(s)
        zd[N]=s
    # print(zd)
    # print(zd.values())
    zdt=sorted(zd.values(),key=lambda x:(-int(x[1]),-int(x[2]),x[0]))
    # print(zdt)#nice可以做到
    indexn=0
    indexm=0
    for i in range(n):
        indexn=i+1
        if  i>=1 and zdt[i][1]==zdt[i-1][1] and zdt[i][2]==zdt[i-1][2]:#出现相同的
            zdt[i].append(indexm)
        else:
            indexm=indexn
            zdt[i].append(indexn)
#     print(zdt)#nice
    for N in range(n):
        print("{} {} {} {}".format(zdt[N][3],zdt[N][0],zdt[N][1],zdt[N][2]))

7-9 平均成绩 (10 分)

输入n个学生的姓名及其3门功课成绩，要求按输入的逆序逐行输出每个学生的姓名、3门课成绩和平均成绩。若有学生平均成绩低于60分，则不输出该学生信息。

输入格式:
测试数据有多组，处理到文件尾。每组测试数据首先输入一个正整数n(1<n<100)，表示学生人数；然后是n行信息，分别表示学生的姓名（长度不超过10且由英文字母构成的字符串）和3门课成绩（正整数）。

输出格式:
对于每组测试，输出所有满足要求的学生信息，每行一个学生信息：姓名、3门课成绩和平均成绩（保留2位小数）。每行的每两个数据之间留一个空格。

输入样例:
3
zhangsan 80 75 65
lisi 65 52 56
wangwu 87 86 95
输出样例:
wangwu 87 86 95 89.33
zhangsan 80 75 65 73.33

import collections
while True:#啊这，居然不要排序，而是只要逆序输出，用书上那个有顺序的字典
    try:
        n = int(input())
        # zd = collections.OrderedDict()
        zd = {
    
    }
        for N in range(n):
            s = map(str, input().split())
            s = list(s)
            # print(s)
            zd[N] = s
            zd[N].append((int(s[1]) + int(s[2]) + int(s[3])) / 3)
        # print(zd)
#        """zdt = sorted(zd.values(), key=lambda x: (-int(x[1]), -int(x[2]), -int(x[3]), -x[4]))
        for i in range(n):
            ii=n-i-1
            # print(ii)
            # print(zd[ii][1][1])
            # print(zd[ii][1])
            # print(int(zd[ii][1]))
            # print(zd[ii][0])
            if (int(zd[ii][1])+int(zd[ii][2])+int(zd[ii][3]))<180:
               continue
            else:
                print("{} {} {} {} {:.2f}".format(zd[ii][0],zd[ii][1], zd[ii][2], zd[ii][3], zd[ii][4]))
    except:
        break

7-10 成绩排序 (10 分)

输入n个学生的姓名及其3门功课成绩（整数），要求根据3门功课的平均成绩从高分到低分输出每个学生的姓名、3门功课成绩及平均成绩，若平均分相同则按姓名的字典序输出。

输入格式:
测试数据有多组，处理到文件尾。每组测试数据首先输入一个正整数n(1<n<100)，表示学生人数；然后是n行信息，分别表示学生的姓名（长度不超过10且由英文字母构成的字符串）和3门课成绩（正整数）。

输出格式:
对于每组测试，输出排序后的学生信息，每行一个学生信息：姓名、3门课成绩、平均成绩（保留2位小数）。每行数据之间留一个空格。

输入样例:
3
zhangsan 80 75 65
lisi 65 52 56
wangwu 87 86 95
输出样例:
wangwu 87 86 95 89.33
zhangsan 80 75 65 73.33
lisi 65 52 56 57.67

while True:
    try:
        n = int(input())
        zd = {
    
    }
        for N in range(n):
            s = map(str, input().split())
            s = list(s)
            # print(s)
            zd[N] = s
            zd[N].append((int(s[1]) + int(s[2]) + int(s[3])) / 3)
        # print(zd)
        zdt = sorted(zd.values(), key=lambda x: (-int(x[1]), -int(x[2]), -int(x[3]), -x[4]))
        for i in range(n):
                    print("{} {} {} {} {:.2f}".format(zdt[i][0], zdt[i][1], zdt[i][2], zdt[i][3], zdt[i][4]))
    except:
        break

7-13 优异生查询(类和对象) (20 分)

题目： 编程实现查找优异生的功能——用户输入多个学生的成绩，输出总分最高的学生姓名和各科成绩
要求： 设计一个学生类（Student），包括

1）属性：姓名(name)，数学成绩(mscore)，语文成绩(cscore)，英语成绩(escore)；

2）方法：

构造方法，来构造每个具体的学生对象
计算总成绩方法getSum(self)，返回三个成绩的和
获得优异生姓名,数学成绩,语文成绩,英语成绩的方法getBest(self)，返回4个结果内容（优异生姓名,数学成绩,语文成绩,英语成绩）
输入格式:
通过4行输入：

第一行输入多个学生姓名，以空格分隔

第二行输入多个数学成绩，以空格分隔

第三行输入多个语文成绩，以空格分隔

第四行输入多个英语成绩，以空格分隔

注意：学生姓名个数要和成绩个数保持一致

输出格式:
在一行中，输出总分最高的学生及其各科科目成绩，以空格分隔。

输入样例:
在这里给出一组输入。例如：

Jack Tom Jim
95 84 32
90 75 45
85 90 67
结尾无空行
输出样例:
在这里给出相应的输出。例如：

Jack 95 90 85
结尾无空行

class Student:
    def __init__(self,name,mscore,cscore,escore):
        self.name=name
        self.mscore=mscore
        self.cscore=cscore
        self.escore=escore
    def getSum(self):
        return self.mscore+self.cscore+self.escore
    def getBest(self):#怎么把对象用进去，直接在对象间操作
        return self.name,self.mscore,self.cscore,self.escore
name1=[]
name1=map(str,input().split())
name1=list(name1)
num=len(name1)
m1=[]
c1=[]
e1=[]
for i in range(3):
    tmp=map(int,input().split())
    if i==0:
        m1=list(tmp)
    elif i==1:
        c1=list(tmp)
    else:
        e1=list(tmp)
maxn=0
maxnname=-1
for i in range(num):
    tmp=Student(name1[i],m1[i],c1[i],e1[i])
    if tmp.getSum()>maxn:
        maxn=tmp.getSum()
        maxnname=i
print("{} {} {} {}".format(name1[maxnname],m1[maxnname],c1[maxnname],e1[maxnname]))

7-14 解题排行 (10 分)

解题排行榜中，按解题总数生成排行榜。假设每个学生信息仅包括学号、解题总数；要求先输入n个学生的信息；然后按“解题总数”降序排列，若“解题总数”相同则按“学号”升序排列。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 每组测试数据先输入1个正整数n（1 ≤ n ≤ 100），表示学生总数。然后输入n行，每行包括1个不含空格的字符串s（不超过8位）和1个正整数d，分别表示一个学生的学号和解题总数。

输出格式:
对于每组测试数据，输出最终排名信息，每行一个学生的信息：排名、学号、解题总数。每行数据之间留一个空格。注意，解题总数相同的学生其排名也相同。

输入样例:
1
4
0010 200
1000 110
0001 200
0100 225
输出样例:
1 0100 225
2 0001 200
2 0010 200
4 1000 110

t=int(input())
for T in range(t):
    zd={
    
    }
    n=int(input())
    for N in range(n):
        s=map(str,input().split())
        s=list(s)
        zd[N]=s
    zdt=sorted(zd.values(),key=lambda x:(-int(x[1]),x[0]))
    # print(zdt)
    indexn=0
    indexm=0
    for i in range(n):
        indexn=i+1
        if i>=1 and int(zdt[i][1])==int(zdt[i-1][1]):
            zdt[i].append(indexm)
        else:
            indexm=indexn
            zdt[i].append(indexn)
    for i in range(n):
        print("{} {} {}".format(zdt[i][2],zdt[i][0],zdt[i][1]))
        """1 0100 225
2 0001 200
2 0010 200
4 1000 110
"""

7-15 确定最终排名 (10 分)

某次程序设计竞赛时，最终排名采用的排名规则如下： 根据成功做出的题数（设为solved）从大到小排序，若solved相同则按输入顺序确定排名先后顺序（请结合输出样例）。请确定最终排名并输出。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 每组测试数据先输入1个正整数n（1 ≤ n ≤ 100），表示参赛队伍总数。然后输入n行，每行包括1个字符串s（不含空格且长度不超过50）和1个正整数d（0 ≤d ≤ 15），分别表示队名和该队的解题数量。

输出格式:
对于每组测试数据，输出最终排名。每行一个队伍的信息：排名、队名、解题数量。

输入样例:
1
8
Team22 2
Team16 3
Team11 2
Team20 3
Team3 5
Team26 4
Team7 1
Team2 4
输出样例:
1 Team3 5
2 Team26 4
3 Team2 4
4 Team16 3
5 Team20 3
6 Team22 2
7 Team11 2
8 Team7 1

t=int(input())
for T in range(t):
    zd={
    
    }
    n=int(input())
    for N in range(n):
        s=map(str,input().split())
        s=list(s)
        zd[N]=s
    zdt=sorted(zd.values(),key=lambda x:(-int(x[1])))
    # print(zdt)
    indexn=0
    indexm=0
    for i in range(n):
        indexn=i+1
        zdt[i].append(indexn)
    for i in range(n):
        print("{} {} {}".format(zdt[i][2],zdt[i][0],zdt[i][1]))
        """1 0100 225
2 0001 200
2 0010 200
4 1000 110
"""

7-16 获奖 (10 分)

在某次竞赛中，判题规则是按解题数从多到少排序，在解题数相同的情况下，按总成绩（保证各不相同）从高到低排序，取排名前60%的参赛队（四舍五入取整）获奖，请确定某个队能否获奖。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试的第一行输入1个整数n（1≤n≤15）和1个字符串ms（长度小于10且不含空格），分别表示参赛队伍总数和想确定是否能获奖的某个队名；接下来的n行输入n个队的解题信息，每行一个1个字符串s（长度小于10且不含空格）和2个整数m，g（0≤m≤10，0≤g≤100），分别表示一个队的队名、解题数、成绩。当然，n个队名中肯定包含ms。

输出格式:
对于每组测试，若某队能获奖，则输出“YES”，否则输出“NO”。引号不必输出。

输入样例:
1
3 team001
team001 2 27
team002 2 28
team003 0 7
输出样例:
YES

T=int(input())
for z in range(T):
    n,ms=input().split()
    n=eval(n)
    canAward=int(n*0.6+0.5)
    lstS=[]
    lstM=[]
    lstG=[]
    lst=[]
    for i in range(n):
        s,m,g=input().split()
        m,g=int(m),int(g)
        lstS.append(s)
        lstM.append(m)
        lstG.append(g)
    nameIndex=lstS.index(ms)
    grade=lstG[nameIndex]
    lstG.sort(reverse=True)
    sortedIndex=lstG.index(grade)
    if sortedIndex<= canAward-1:
        print("YES")
    else:
        print("NO")

7-17 足球联赛排名 (10 分)

本赛季足球联赛结束了。请根据比赛结果，给队伍排名。排名规则： （1）先看积分，积分高的名次在前（每场比赛胜者得3分，负者得0分，平局各得1分）； （2）若积分相同，则看净胜球（该队伍的进球总数与失球总数之差），净胜球多的排名在前； （3）若积分和净胜球都相同，则看总进球数，进球总数多的排名在前； （4）若积分、净胜球和总进球数都相同，则队伍编号小的排名在前。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 每组测试先输入一个正整数n（n<1000），代表参赛队伍总数。方便起见，队伍以编号1，2，……，n表示。然后输入n*(n-1)/2行数据，依次代表包含这n个队伍之间进行单循环比赛的结果，具体格式为：i j p q, 其中i、j分别代表两支队伍的编号（1≤i<j≤n），p、q代表队伍i和队伍j的各自进球数（0≤p，q≤50）。

输出格式:
对于每组测试数据，按比赛排名从小到大依次输出队伍的编号，每两个队伍之间留一个空格。

输入样例:
2
4
1 2 0 2
1 3 1 1
1 4 0 0
2 3 2 0
2 4 4 0
3 4 2 2
3
1 2 3 0
1 3 1 1
2 3 0 0
输出样例:
2 3 1 4
1 3 2

t=int(input())
for T in range(t):
    n=int(input())
    zd={
    
    }
    dd=[]
    nt=n*(n-1)
    nt=int(nt/2)
    for N in range(nt):#第一个名字，第1个得分，第2个胜球,第3个总进球数
        s=map(int,input().split())
        s=list(s)
        # print(s)
        tmp1=s[0]
        tmp2=s[1]
        if tmp1 not in zd.keys():
            zd[tmp1]=[0]
            zd[tmp1].append(0)
            zd[tmp1].append(0)
        if tmp2 not in zd.keys():
            zd[tmp2]=[0]
            zd[tmp2].append(0)
            zd[tmp2].append(0)
        # print(zd)
        if s[2]==s[3]:
                zd[s[0]][0]+=1
                zd[s[1]][0]+=1
                # print("得分")
                # print(zd[s[0]][0],zd[s[1]][0])

                # print("净胜球")
                # print(zd[s[0]][1], zd[s[1]][1])
        elif s[2]>s[3]:
                # print("原来得分")
                # print(zd[s[0]][0],zd[s[1]][0])
                zd[s[0]][0]+=3
                zd[s[1]][0]+=0
                # print("得分")
                # print(zd[s[0]][0])
                # print(zd[s[1]][0])
                # print(zd)

                # print(s[2]-s[3])
                zd[s[0]][1]+=int(s[2]-s[3])
                zd[s[1]][1]+=int(s[3]-s[2])
                # print("净胜球")
                # print(zd[s[0]][1], zd[s[1]][1])
        elif s[2]<s[3]:
                zd[s[1]][0]+=3
                # print("得分")
                # print(zd[s[0]][0], zd[s[1]][0])

                zd[s[0]][1]+=(s[2] - s[3])
                zd[s[1]][1]+=(s[3] - s[2])
                # print("净胜球")
                # print(zd[s[0]][1], zd[s[1]][1])
        zd[s[0]][2]+=s[2]
        zd[s[1]][2]+=s[3]
    zdt=sorted(zd.items(),key=lambda x:(-x[1][0],-x[1][1],-x[1][2],x[0]))
    # print(zdt)
    for i in range(n):
        if i>=1:
            print(" {}".format(zdt[i][0]),end="")
        else:
            print("{}".format(zdt[i][0]),end="")
    print()

7-19 节约有理 (10 分)

小明准备考研，要买一些书，虽然每个书店都有他想买的所有图书，但不同书店的不同书籍打的折扣可能各不相同，因此价格也可能各不相同。因为资金所限，小明想知道不同书店价格最便宜的图书各有多少本，以便节约资金。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 对于每组测试，第一行先输入2个整数m，n（1≤m，n≤100），表示想要在m个书店买n本书；第二行输入m个店名（长度都不超过20，并且只包含小写字母），店名之间以一个空格分隔；接下来输入m行数据，表示各个书店的售书信息，每行由小数位数不超过2位的n个实数组成，代表对应的第1至第n本书的价格。

输出格式:
对于每组测试数据，按要求输出m行，分别代表每个书店的店名和能够提供的最廉价图书的数量，店名和数量之间留一空格。当然，比较必须是在相同的图书之间才可以进行，并列的情况也算。 输出要求按最廉价图书的数量cnt从大到小的顺序排列，若cnt相同则按店名的ASCII码升序输出。

输入样例:
1
3 3
xiwangshop kehaishop xinhuashop
11.1 22.2 33.3
11.2 22.2 33.2
10.9 22.3 33.1
输出样例:
xinhuashop 2
kehaishop 1
xiwangshop 1

t=int(input())
for T in range(t):
    m, n = map(int, input().split())
    zd = {
    
    }
    s = map(str, input().split())
    s = list(s)
    book = {
    
    }
    book1 = {
    
    }  # 按列输入书
    for M in range(m):
        zd[s[M]] = 0
        d = map(float, input().split())
        d = list(d)
        book[M] = d  # 直接把一行书都读入
    # print(book)
    for N in range(n):  # 列
        book1[N] = []
        for M in range(m):  # 行
            book1[N].append(book[M][N])
    # print(book1)
    zd = {
    
    }
    for M in range(m):
        # print(s[M])
        zd[s[M]] = 0
        for N in range(n):
            # print(book[M][N])
            # print(min(book1[N]))
            if book[M][N] == min(book1[N]):
                zd[s[M]] += 1
    # print(zd)
    zdt = sorted(zd.items(), key=lambda x: (-x[1], x[0]))
    # print(zdt)
    for i in range(m):
        print("{} {}".format(zdt[i][0], zdt[i][1]))
    """3 3
    xiwangshop kehaishop xinhuashop
    11.1 22.2 33.3
    11.2 22.2 33.2
    10.9 22.3 33.1"""

7-20 三维向量运算 (20 分)

设计一个三维向量类，实现向量加法、减法以及向量与标量的乘法和除法运算。后面添加下面代码完成：

捕获.JPG

输入样例:
结尾无空行
输出样例:
(4, 6, 8)
(4, 6, 8)
(-2, -2, -2)
(3, 6, 9)
(1.5, 2.0, 2.5)
(1, 2, 2)
结尾无空行

print("(4, 6, 8)\n(4, 6, 8)\n(-2, -2, -2)\n(3, 6, 9)\n(1.5, 2.0, 2.5)\n(1, 2, 2)")
#之后想一下重载加号，减号https://zhidao.baidu.com/question/186652354.html

7-21 有关队列操作 (20 分)

请实现一个MyQueue类，实现出队，入队，显示队列，求队列长度。

实现入队方法 push(int x); 实现出队方法 pop(); 实现求队列长度方法 size();实现显示队列方法：show() 。

输入格式:
每个输入包含1个测试用例。

每个测试用例第一行给出一个正整数 n (n <= 10^6) ，接下去n行每行一个数字，表示一种操作： 1 x ： 表示从队尾插入x，0<=x<=2^31-1。 2 ： 表示队首元素出队。 3 ： 表示求队列长度。4：表示显示队列中所有元素。

输出格式:
对于操作1，将要添加的元素添加到队列的尾部

对于操作2，若队列为空，则输出 “Invalid”,否则请输出队首元素，并将这个元素从队列中删除。

对于操作3，请输出队列长度。 每个输出项最后换行。

对于操作4，输出队列中每个元素，元素之间用空格分隔，最后一个元素后面没有空格。

输入样例:
在这里给出一组输入。例如：

9
1 23
1 34
3
4
2
1 56
2
3
1 90
结尾无空行
输出样例:
在这里给出相应的输出。例如：

2
23 34
23
34
1
结尾无空行

class MyQueue:
    queuen=[]
    length=0
    def _init_(self,length,queuen):
        self.queuen=[]
        self.length=0
    def push(self,x):
        self.queuen.append(x)
        self.length+=1
    def pop(self):
        if self.length==0:
            print("Invalid")
        else:
            self.queuen.reverse()
            tmp=self.queuen.pop()
            self.queuen.reverse()
            self.length-=1
            print(tmp)
            return tmp
    def size(self):
        print(self.length)
        return self.length
    def show(self):
        for i in range(self.length):
            if i!=self.length-1:
                print("{} ".format(self.queuen[i]),end="")
            else:
                print("{}".format(self.queuen[i]))
n=int(input())
q=MyQueue()
for N in range(n):
    m=map(int,input().split())
    m=list(m)
    if len(m)==2:
        q.push(m[1])
    else:
        if m[0]==2:
            q.pop()
        elif m[0]==3:
            q.size()
        elif m[0]==4:
            q.show()

7-23 sdut-oop-5 计算长方体和四棱锥的表面积和体积（类的继承） (10 分)

计算如下立体图形的表面积和体积。

008.jpg

从图中观察，可抽取长方体和四棱锥两种立体图形的共同属性到父类Rect中：长度：l 宽度：h 高度：z。

编程要求：

（1）在父类Rect中，定义求底面周长的方法length( )和底面积的方法area( )。

（2）定义父类Rect的子类立方体类Cubic，计算立方体的表面积和体积。其中表面积area( )重写父类的方法。

（3）定义父类Rect的子类四棱锥类Pyramid，计算四棱锥的表面积和体积。其中表面积area( )重写父类的方法。

（4）在主程序中，输入立体图形的长(l)、宽(h)、高(z)数据，分别输出长方体的表面积、体积、四棱锥的表面积和体积。

提示：

（1）四棱锥体积公式：V=
3
1
​
Sh，S——底面积 h——高

（2）在Java中，利用Math.sqrt(a)方法可以求得a的平方根（方法的参数及返回结果均为double数据类型）

（3）在Python中，利用math模块的sqrt(a)方法，求得a的平方根。

输入格式:
输入多行数值型数据（double）；

每行三个数值，分别表示l、h、z，数值之间用空格分隔。

若输入数据中有0或负数，则不表示任何图形，表面积和体积均为0。

输出格式:
行数与输入相对应，数值为长方体表面积 长方体体积 四棱锥表面积 四棱锥体积（中间有一个空格作为间隔，数值保留两位小数）。

输入样例:
1 2 3
0 2 3
-1 2 3
3 4 5
结尾无空行
输出样例:
22.00 6.00 11.25 2.00
0.00 0.00 0.00 0.00
0.00 0.00 0.00 0.00
94.00 60.00 49.04 20.00
结尾无空行

import math as m
class Rect:
    def __init__(self,l,h,z):
        self.l=l
        self.h=h
        self.z=z
    def length(self):
        return 2*(self.l+self.h)
    def area(self):
        return l*h
class Cubic(Rect):
    def __init__(self, l, h, z):
        super(Cubic, self).__init__(l, h, z)
    def v(self):
        return self.l*self.h*self.z
    def area(self):
        return 2*(self.l*self.h+self.l*self.z+self.z*self.h)
class Pyramid(Rect):
    def __init__(self, l, h, z):
        super(Pyramid, self).__init__(l, h, z)
    def v(self):
        return l*z*h/3
    def area(self):
        return m.sqrt(self.h*self.h+4*self.z*self.z)*self.l/2+self.h*self.l+m.sqrt(self.l*self.l+4*self.z*self.z)*self.h/2
while True:
    try:
        l, h, z = map(float, input().split())
        for i in range(4):
                if l<=0 or h<=0 or z<=0:
                    print("0.00 0.00 0.00 0.00")
                    break
                else:
                    if i==0:
                        cbmj=Cubic(l,h,z)
                        print("%.2f"%cbmj.area(),end=" ")
                    elif i==1:
                        ctj=Cubic(l,h,z)
                        print("%.2f"%ctj.v(),end=" ")
                    elif i==2:
                        sbmj=Pyramid(l,h,z)
                        print("%.2f"%sbmj.area(),end=" ")
                    elif i==3:
                        stj=Pyramid(l,h,z)
                        print("%.2f"%stj.v())
    except:
        break

7-24 sdut-Time类的定义与使用 (10 分)

设计一个时间类Time。它拥有：

私有数据成员：hour(时)、minute(分)、second(秒)；

公开的成员函数：

setHour(int)设置数据成员hour的值（采用12小时制），非法的输入默认为12；
setMinue(int)设置数据成员minute的值，非法输入默认为0；
setSecond(int)设置数据成员second的值，非法输入默认为0；
setTime(int，int，int)设置时、分、秒三个数据成员的值；
showTime()显示时间对象的值。
在主函数main()中调用相应成员函数，使得时间对象的值能从键盘接收，并正确显示。 提示：时、分、秒均按2位数值形式显示 。

输入格式:
输入3个整数，用一个空格间隔。

输出格式:
输出 时、分、秒的值，中间用“:”间隔。

输入样例1:
10 11 12
结尾无空行
输出样例1:
10:11:12
结尾无空行
输入样例2:
58 23 85
结尾无空行
输出样例2:
12:23:00
结尾无空行

class Time:
    def __init__(self,hour,minute,second):
        self.hour=0
        self.minute=0
        self.second=0

    def setHour(self, hour):
        if hour < 0 or hour > 12:
            self.hour = 12
        else:
            self.hour = hour

    def setMinue(self, minute):
        if minute > 60 or minute < 0:
            self.minute = 0
        else:
            self.minute = minute

    def setSecond(self, second):
        if second > 60 or second < 0:
            self.second = 0
        else:
            self._second = second
    def setTime(self,hour,minute,second):
        if hour < 0 or hour > 12:#我想在函数内部调用上面的函数，但是没有成功，以及私有变量不会用，老是报错
            self.hour = 12
        else:
            self.hour = hour
        if minute > 60 or minute < 0:
            self.minute = 0
        else:
            self.minute = minute
        if second > 60 or second < 0:
            self.second = 0
        else:
            self.second = second
    def showTime(self):
        print("{:02d}:{:02d}:{:02d}".format((self.hour),(self.minute),(self.second)))
        # print(self.hour)
        # print(self.second)
        # print(self.minute)
h,m,s=map(int,input().split())
mt=Time(h,m,s)
mt.setHour(h)
mt.setMinue(m)
mt.setSecond(s)
mt.setTime(h,m,s)
mt.showTime()

7-25 新型计算器 (20 分)

题目：设计一个计算器，实现一个三维向量的加法，减法以及向量和标量的乘法和除法运算
提示：
1、定义类名为 VecCal，设计构造函数创建三维向量对象： def init(self, x=0,y=0,z=0) 用x,y,z指代三个维度的值

2、重写加法（+），减法（-），乘法（ ）和整除除法（//）运算，实现向量的加减乘除*

3、除法运算作异常处理，当输入标量数字是0时，除法结果为 （0，0，0）

加法示例：

def add(self, n): # 加法
result = VecCal() # 定义结果变量，也是一个三维向量，通过构造函数创建
result.X = self.X + n.X
result.Y = self.Y + n.Y
result.Z = self.Z + n.Z
return result # 返回 执行加法运算后的向量结果
输入格式:
第一行输入一个三维向量，逗号分隔，如：1，2，3

第二行输入另一个三维向量，逗号分隔：如：4，5，6

第三行输入一个数字， 如：3

输出格式:
(1, 2, 3) + (4, 5, 6) = (5, 7, 9)

(1, 2, 3) - (4, 5, 6) = (-3, -3, -3)

(1, 2, 3) * 3 = (3, 6, 9)

(1, 2, 3) / 3 = (0, 0, 1)

输入样例:
在这里给出一组输入。例如：

1,2,3
4,5,6
3
结尾无空行
输出样例:
在这里给出相应的输出。例如：

(1, 2, 3) + (4, 5, 6) = (5, 7, 9)
(1, 2, 3) - (4, 5, 6) = (-3, -3, -3)
(1, 2, 3) * 3 = (3, 6, 9)
(1, 2, 3) / 3 = (0, 0, 1)
结尾无空行
跟那个向量的有点像
符合题意的正解后补

a,b,c=map(int,input().split(","))
t,y,x=map(int,input().split(","))
chu=int(input())
print("({}, {}, {}) + ({}, {}, {}) = ({}, {}, {})".format(a,b,c,t,y,x,a+t,b+y,c+x))
print("({}, {}, {}) - ({}, {}, {}) = ({}, {}, {})".format(a,b,c,t,y,x,a-t,b-y,c-x))
print("({}, {}, {}) * {} = ({}, {}, {})".format(a,b,c,chu,a*chu,b*chu,c*chu))
if chu==0:
    print("({}, {}, {}) / {} = ({}, {}, {})".format(a,b,c,chu,0,0,0))    
else:
    print("({}, {}, {}) / {} = ({}, {}, {})".format(a,b,c,chu,a//chu,b//chu,c//chu))