实验03-python的组合数据类型

1004 成绩排名

问题描述：

读入 n（>0）名学生的姓名、学号、成绩，分别输出成绩最高和成绩最低学生的姓名和学号。

输入说明：

每个测试输入包含 1 个测试用例，格式为
第 1 行：正整数 n
第 2 行：第 1 个学生的姓名 学号 成绩
第 3 行：第 2 个学生的姓名 学号 成绩
… … …
第 n+1 行：第 n 个学生的姓名 学号 成绩
其中姓名和学号均为不超过 10 个字符的字符串，成绩为 0 到 100 之间的一个整数，这里保证在一组测试用例中没有两个学生的成绩是相同的。

输出说明：

对每个测试用例输出 2 行，第 1 行是成绩最高学生的姓名和学号，第 2 行是成绩最低学生的姓名和学号，字符串间有 1 空格。

输入样列：

3
Joe Math990112 89
Mike CS991301 100
Mary EE990830 95

输出样列：

Mike CS991301
Joe Math990112

代码：

a = int(input())
mx = -0xffffffff
mn = 0xffffffff
for i in range(a):
    lt = input().split()
    if int(lt[2]) > mx:
        mxans = lt
        mx = int(lt[2])
    if int(lt[2]) < mn:
        mnans = lt
        mn = int(lt[2])
print(mxans[0] + " " + mxans[1])
print(mnans[0] + " " + mnans[1])

1008 数组元素循环右移问题

问题描述：

一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥0）个位置，即将A中的数据由（A0A1⋯AN−1）变换为（AN−M⋯AN−1A0A1⋯AN−M−1）（最后M个数循环移至最前面的M个位置）。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入说明：

每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。

输出说明：

在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样列：

6 2
1 2 3 4 5 6

输出样列：

5 6 1 2 3 4

代码：

n, m = map(int, input().split())
lst = list(map(int, input().split()))
lst = map(str, lst[n - m:] + lst[:n - m])
print(' '.join(lst))

1009 说反话

问题描述：

给定一句英语，要求你编写程序，将句中所有单词的顺序颠倒输出。

输入说明：

测试输入包含一个测试用例，在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成，其中单词是由英文字母（大小写有区分）组成的字符串，单词之间用 1 个空格分开，输入保证句子末尾没有多余的空格。

输出说明：

每个测试用例的输出占一行，输出倒序后的句子。

输入样列：

Hello World Here I Come

输出样列：

Come I Here World Hello

代码：

st = input().split()
st.reverse()
print(' '.join(st))

1010 一元多项式求导

问题描述：

设计函数求一元多项式的导数。（注：xn（n为整数）的一阶导数为nxn−1。）。

输入说明：

以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过 1000 的整数）。数字间以空格分隔。

输出说明：

以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是 0，但是表示为 0 0。

输入样列：

3 4 -5 2 6 1 -2 0

输出样列：

12 3 -10 1 6 0

代码：

a = input().split()
x = []
for i in range(0, len(a), 2):
    m = int(a[i]) * int(a[i + 1])
    n = int(a[i + 1]) - 1
    if n == -1:
        break
    x.append(str(m))
    x.append(str(n))
if len(x) == 0:
    print('0 0')
else:
    print(' '.join(x))

1016 部分A+B

问题描述：

正整数 A 的“DA（为 1 位整数）部分”定义为由 A 中所有 DA 组成的新整数 PA。例如：给定 A=3862767，DA=6，则 A 的“6 部分”PA 是 66，因为 A 中有 2 个 6。
现给定 A、DA、B、DB，请编写程序计算 PA+PB。

输入说明：

输入在一行中依次给出 A、DA、B、DB，中间以空格分隔，其中 0<A,B<1010。

输出说明：

在一行中输出 PA+PB 的值。

输入样列：

3862767 6 13530293 3

输出样列：

399

代码：

lst = list(input().split())
num1 = lst[0].count(lst[1])
num2 = lst[2].count(lst[3])
sum1, sum2 = 0, 0
for i in range(num1):
    sum1 = sum1 * 10 + int(lst[1])
for i in range(num2):
    sum2 = sum2 * 10 + int(lst[3])
print(sum1 + sum2)

1020 月饼

问题描述：

月饼是中国人在中秋佳节时吃的一种传统食品，不同地区有许多不同风味的月饼。现给定所有种类月饼的库存量、总售价、以及市场的最大需求量，请你计算可以获得的最大收益是多少。
注意：销售时允许取出一部分库存。样例给出的情形是这样的：假如我们有 3 种月饼，其库存量分别为 18、15、10 万吨，总售价分别为 75、72、45 亿元。如果市场的最大需求量只有 20 万吨，那么我们最大收益策略应该是卖出全部 15 万吨第 2 种月饼、以及 5 万吨第 3 种月饼，获得 72 + 45/2 = 94.5（亿元）。

输入说明：

每个输入包含一个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N 表示月饼的种类数、以及不超过 500（以万吨为单位）的正整数 D 表示市场最大需求量。随后一行给出 N 个正数表示每种月饼的库存量（以万吨为单位）；最后一行给出 N 个正数表示每种月饼的总售价（以亿元为单位）。数字间以空格分隔。

输出说明：

对每组测试用例，在一行中输出最大收益，以亿元为单位并精确到小数点后 2 位。

输入样列：

3 20
18 15 10
75 72 45

输出样列：

94.50

代码：

n, m = map(int, input().split())
num = list(map(float, input().split()))
price = list(map(float, input().split()))
rate = {i: price[i] / num[i] for i in range(n)}
order = sorted(rate, key=lambda i: rate[i], reverse=True)
money = 0
for i in order:
    if m >= num[i]:
        money += price[i]
        m -= num[i]
    else:
        money += m * rate[i]
        break
print("%.2f" % money)

1021 个位数统计

问题描述：

给定一个 k 位整数 N=dk−110k−1+⋯+d1101+d0 (0≤di≤9, i=0,⋯,k−1, dk−1>0)，请编写程序统计每种不同的个位数字出现的次数。例如：给定 N=100311，则有 2 个 0，3 个 1，和 1 个 3。

输入说明：

每个输入包含 1 个测试用例，即一个不超过 1000 位的正整数 N。

输出说明：

对 N 中每一种不同的个位数字，以 D:M 的格式在一行中输出该位数字 D 及其在 N 中出现的次数 M。要求按 D 的升序输出。

输入样列：

100311

输出样列：

0:2
1:3
3:1

代码：

lt = input()
for i in range(10):
    if lt.count(str(i)) != 0:
        print("%d:%d" % (i, lt.count(str(i))))

1027 打印沙漏

问题描述：

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印

所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。
给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。

输入说明：

输入在一行给出1个正整数N（≤1000）和一个符号，中间以空格分隔。

四、输出说明：
首先打印出由给定符号组成的最大的沙漏形状，最后在一行中输出剩下没用掉的符号数。

输入样列：

19 *

输出样列：

2

代码：

构成沙漏的个数为x*x-1，找一下规律即可

n = input().split()
c = n[1]
k = int(((int(n[0]) + 1) // 2) ** (0.5))
for i in range(1, k + 1):
    for j in range(i - 1):
        print(end=' ')
    for j in range(2 * (k - i) + 1):
        print(c, end='')
    print()
for i in range(1, k):
    for j in range(k - i - 1):
        print(end=' ')
    for j in range(2 * i + 1):
        print(c, end='')
    print()
print("%d" % (int(n[0]) + 1 - 2 * k * k))

1031 查验身份证

问题描述：

一个合法的身份证号码由17位地区、日期编号和顺序编号加1位校验码组成。校验码的计算规则如下：
首先对前17位数字加权求和，权重分配为：{7，9，10，5，8，4，2，1，6，3，7，9，10，5，8，4，2}；然后将计算的和对11取模得到值Z；最后按照以下关系对应Z值与校验码M的值：
Z：0 1 2 3 4 5 6 7 8 9 10
M：1 0 X 9 8 7 6 5 4 3 2
现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。

输入说明：

输入第一行给出正整数N（≤100）是输入的身份证号码的个数。随后N行，每行给出1个18位身份证号码。

输出说明：

按照输入的顺序每行输出1个有问题的身份证号码。这里并不检验前17位是否合理，只检查前17位是否全为数字且最后1位校验码计算准确。如果所有号码都正常，则输出All passed。

输入样列1：

4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X

输出样列1：

12010X198901011234
110108196711301866
37070419881216001X

输入样列2：

2
320124198808240056
110108196711301862

输出样列2：

All passed

代码：

def func(num, a, z):
    sum = 0
    x = 0
    for i in num[:17]:
        if i >= '0' and i <= '9':
            sum += int(i) * z[x]
            x += 1
        else:
            return False

    remainder = sum % 11
    if a[remainder] == num[-1]:
        return True
    else:
        return False

n = int(input())
count = 0
a = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2']
z = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
for i in range(n):
    num = input()
    if func(num, a, z) == False:
        print(num)
    else:
        count += 1
if count == n:
    print("All passed")

1038 统计同成绩学生

问题描述：

本题要求读入 N 名学生的成绩，将获得某一给定分数的学生人数输出。

输入说明：

输入在第 1 行给出不超过 105的正整数 N，即学生总人数。随后一行给出 N 名学生的百分制整数成绩，中间以空格分隔。最后一行给出要查询的分数个数 K（不超过 N 的正整数），随后是 K 个分数，中间以空格分隔。

输出说明：

在一行中按查询顺序给出得分等于指定分数的学生人数，中间以空格分隔，但行末不得有多余空格。

输入样列：

10
60 75 90 55 75 99 82 90 75 50
3 75 90 88

输出样列：

3 2 0

代码：

n = int(input())
lst = list(map(int, input().split()))
num = [0 for i in range(101)]
for i in lst:
    num[i] += 1
lt = list(map(int, input().split()))
ans = []
for i in lt[1:]:
    ans.append(str(num[i]))
print(' '.join(ans))

1039 到底买不买

问题描述：

小红想买些珠子做一串自己喜欢的珠串。卖珠子的摊主有很多串五颜六色的珠串，但是不肯把任何一串拆散了卖。于是小红要你帮忙判断一下，某串珠子里是否包含了全部自己想要的珠子？如果是，那么告诉她有多少多余的珠子；如果不是，那么告诉她缺了多少珠子。
为方便起见，我们用[0-9]、[a-z]、[A-Z]范围内的字符来表示颜色。例如在图1中，第3串是小红想做的珠串；那么第1串可以买，因为包含了全部她想要的珠子，还多了8颗不需要的珠子；第2串不能买，因为没有黑色珠子，并且少了一颗红色的珠子。

输入说明：

每个输入包含 1 个测试用例。每个测试用例分别在 2 行中先后给出摊主的珠串和小红想做的珠串，两串都不超过 1000 个珠子。

输出说明：

如果可以买，则在一行中输出 Yes 以及有多少多余的珠子；如果不可以买，则在一行中输出 No 以及缺了多少珠子。其间以 1 个空格分隔。

输入样列1：

ppRYYGrrYBR2258
YrR8RrY

输出样列1：

Yes 8

输入样列2：

ppRYYGrrYB225
YrR8RrY

输出样列2：

No 2

代码：

lst1 = input()
lst2 = input()
num1, num2 = 0, 0
tlt = list(lst1)
for i in lst2:
    if i in tlt:
        tlt.remove(i)
        num1 += 1
    else:
        num2 += 1
if num1 == len(lst2):
    print("Yes" + ' ' + str(len(lst1) - num1))
else:
    print("No" + ' ' + str(num2))

1041 考试座位号

问题描述：

每个 PAT 考生在参加考试时都会被分配两个座位号，一个是试机座位，一个是考试座位。正常情况下，考生在入场时先得到试机座位号码，入座进入试机状态后，系统会显示该考生的考试座位号码，考试时考生需要换到考试座位就座。但有些考生迟到了，试机已经结束，他们只能拿着领到的试机座位号码求助于你，从后台查出他们的考试座位号码。

输入说明：

输入第一行给出一个正整数 N（≤1000），随后 N 行，每行给出一个考生的信息：准考证号 试机座位号 考试座位号。其中准考证号由 16 位数字组成，座位从 1 到 N 编号。输入保证每个人的准考证号都不同，并且任何时候都不会把两个人分配到同一个座位上。
考生信息之后，给出一个正整数 M（≤N），随后一行中给出 M 个待查询的试机座位号码，以空格分隔。

输出说明：

对应每个需要查询的试机座位号码，在一行中输出对应考生的准考证号和考试座位号码，中间用 1 个空格分隔。

输入样列：

4
3310120150912233 2 4
3310120150912119 4 1
3310120150912126 1 3
3310120150912002 3 2
2
3 4

输出样列：

3310120150912002 2
3310120150912119 1

代码：

n = int(input())
lst = [[] for i in range(n + 1)]
for i in range(n):
    id, num1, num2 = input().split()
    num1 = int(num1)
    lst[num1].append(id)
    lst[num1].append(num2)
m = int(input())
lt = list(map(int, input().split()))
for i in lt:
    print(lst[i][0], lst[i][1])

1043 输出PATest

问题描述：

给定一个长度不超过 104的、仅由英文字母构成的字符串。请将字符重新调整顺序，按 PATestPATest… 这样的顺序输出，并忽略其它字符。当然，六种字符的个数不一定是一样多的，若某种字符已经输出完，则余下的字符仍按 PATest 的顺序打印，直到所有字符都被输出。

输入说明：

输入在一行中给出一个长度不超过 104的、仅由英文字母构成的非空字符串。

输出说明：

在一行中按题目要求输出排序后的字符串。题目保证输出非空。

输入样列：

redlesPayBestPATTopTeePHPereatitAPPT

输出样列：

PATestPATestPTetPTePePee

代码：

lst = list(map(str, input()))
mp = {'P': 0, 'A': 0, 'T': 0, 'e': 0, 's': 0, 't': 0}
for i in lst:
    if i in mp:
        mp[i] += 1
while 1:
    flag = 0
    for i in mp:
        if mp[i] != 0:
            flag = 1
            mp[i] -= 1
            print(i, end='')
    if flag == 0:
        print()
        break

1047 编程团体赛

问题描述：

编程团体赛的规则为：每个参赛队由若干队员组成；所有队员独立比赛；参赛队的成绩为所有队员的成绩和；成绩最高的队获胜。
现给定所有队员的比赛成绩，请你编写程序找出冠军队。

输入说明：

输入第一行给出一个正整数 N（≤104），即所有参赛队员总数。随后 N 行，每行给出一位队员的成绩，格式为：队伍编号-队员编号 成绩，其中队伍编号为 1 到 1000 的正整数，队员编号为 1 到 10 的正整数，成绩为 0 到 100 的整数。

输出说明：

在一行中输出冠军队的编号和总成绩，其间以一个空格分隔。注意：题目保证冠军队是唯一的。

输入样列：

6
3-10 99
11-5 87
102-1 0
102-3 100
11-9 89
3-2 61

输出样列：

11 176

代码：

n = int(input())
dir = {}

for i in range(n):
    team, per, grade = input().replace('-', ' ').split()
    grade = int(grade)
    if team in dir:
        dir[team] += grade
    else:
        dir[team] = 0
        dir[team] += grade

mx = 0
for key, value in dir.items():
    if value > mx:
        mx = value
        flag = key
print(flag + ' ' + str(mx))

1072 开学寄语

问题描述：

下图是上海某校的新学期开学寄语：天将降大任于斯人也，必先删其微博，卸其 QQ，封其电脑，夺其手机，收其 ipad，断其 wifi，使其百无聊赖，然后，净面、理发、整衣，然后思过、读书、锻炼、明智、开悟、精进。而后必成大器也！
本题要求你写个程序帮助这所学校的老师检查所有学生的物品，以助其成大器。

输入说明：

输入第一行给出两个正整数 N（≤ 1000）和 M（≤ 6），分别是学生人数和需要被查缴的物品种类数。第二行给出 M 个需要被查缴的物品编号，其中编号为 4 位数字。随后 N 行，每行给出一位学生的姓名缩写（由 1-4 个大写英文字母组成）、个人物品数量 K（0 ≤ K ≤ 10）、以及 K 个物品的编号。

输出说明：

顺次检查每个学生携带的物品，如果有需要被查缴的物品存在，则按以下格式输出该生的信息和其需要被查缴的物品的信息（注意行末不得有多余空格）：
姓名缩写: 物品编号1 物品编号2 ……
最后一行输出存在问题的学生的总人数和被查缴物品的总数。

输入样列：

4 2
2333 6666
CYLL 3 1234 2345 3456
U 4 9966 6666 8888 6666
GG 2 2333 7777
JJ 3 0012 6666 2333

输出样列：

U: 6666 6666
GG: 2333
JJ: 6666 2333
3 5

代码：

n, m = map(int, input().split())
lst = input().split()
num1, num2 = 0, 0
for i in range(n):
    lt = input().split()
    x = []
    flag = 0
    for j in lt[2:]:
        if j in lst:
            x.append(j)
            num2 += 1
            flag = 1
    if flag == 1:
        num1 += 1
        print(lt[0] + ': ', end="")
        print(" ".join(x))
print("%d %d" % (num1, num2))

1091 N-自守数

问题描述：

如果某个数 K 的平方乘以 N 以后，结果的末尾几位数等于 K，那么就称这个数为“N-自守数”。例如 3×922 =25392，而 25392 的末尾两位正好是 92，所以 92 是一个 3-自守数。
本题就请你编写程序判断一个给定的数字是否关于某个 N 是 N-自守数。

输入说明：

输入在第一行中给出正整数 M（≤20），随后一行给出 M 个待检测的、不超过 1000 的正整数。

输出说明：

对每个需要检测的数字，如果它是 N-自守数就在一行中输出最小的 N 和 NK2 的值，以一个空格隔开；否则输出 No。注意题目保证 N<10。

输入样列：

3
92 5 233

输出样列：

3 25392
1 25
No

代码：

n = int(input())
lst = list(input().split())
for i in lst:
    f = 0
    length = 10 ** len(i)
    for j in range(1, 10):
        if (j * int(i) ** 2) % length == int(i):
            f = 1
            print(j, j * int(i) ** 2)
            break
    if f == 0:
        print("No")