HibisciDai 主页关于我归档标签分类相册
实用Python程序设计MOOC-期末考试
|学习笔记
字数总计: 5k|阅读时长: 19 分钟

实用Python程序设计MOOC-期末考试

[TOC]

实用Python程序设计MOOC-期末考试

001:好数坏数

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    输入一个正整数，如果是5和7的公倍数，就输出 best，如果不是7的倍数，但是是5的倍数就输出good，其它情况就输出bad。注意这些词都是小写

  • 输入

一个正整数n

  • 输出

根据要求输出best,good或bad

  • 样例输入
1
2
3
4
5
6
样例#1
35
样例#2
14
样例#3
10
  • 样例输出
1
2
3
4
5
6
样例#1
best
样例#2
bad
样例#3
good
  • 提交代码
1
2
3
4
5
6
7
x = int(input())
if x%5==0 and x%7 ==0:
    print("best")
elif x%5==0 and x%7 !=0:
    print("good")
else:
    print("bad")

c8e2bd0b8c41c837477d97d171d2b0d18c94b1e12e165f267ba4eae0a9820feb

002:买手办

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    小明到了手办店非常开心，要大买特买。但他不是大富豪，所以只能买不超过60元手办。
    现在知道若干手办的价钱，请计算小明一共要花掉多少钱。

  • 输入
    一行，若干个正整数，每个正整数表示一个手办的价钱

  • 输出
    小明会买下所有不超过60元的手办。输出他将要花掉多少钱

  • 样例输入
    120 60 60 30 50 10 100

  • 样例输出
    210

  • 提交代码

1
2
3
4
5
6
7
8
inputs = input()
strs = inputs.split()
result = 0
for i in range(len(strs)):
    temp = int(strs[i])
    if (temp <= 60):
        result += temp
print(result)

38909039d002e176bb0d31314f80d7f412c6cfc1470a7b966f4375e61ffb47f0

003:字符计数

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    一个句子中有多个单词，单词之间可能有一个或多个空格。给定一个字符，请计算该字符在每个单词中的出现次数。 本题目不区分大小写字母。例如，字符A与字符a在单词Abandon中的出现次数都认为是2。 本题目有多组输入数据。

  • 输入
    第一行一个整数n，表示数据组数；
    接下来共2n行，每两行为一组：
    每组中第一行为给定的字符，保证为小写或大写字母；
    每组中第二行为输入的句子，保证只由大小写字母或空格组成，且第一个单词前与最后一个单词后都没有空格。

  • 输出
    n行，每行若干个整数，表示句子的每个单词中，给定字符的出现次数。
    每行的相邻整数之间用一个空格分隔。

行末多输出了空格没有关系

  • 样例输入

    1
    2
    3
    4
    5
    6
    7
    3
    a
    Abandon that
    B
    Bob  is   the  BIG BOSS
    z
    Zelda   ZZZ

  • 样例输出

    1
    2
    3
    2 1
    2 0 0 1 1
    1 3

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
zu = int(input())

for i in range(zu):
    itChar = input().lower()

    comChar = input().lower()
    strs = comChar.split()

    for j in range(len(strs)):
        print(strs[j].count(itChar), end=" ")
    print()

46eaa2d6f68b4a55bbeee44daf4e7dcf9959a3d39d9cf751dee5a7de05cd8aaa

004:括号内的信息

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    程序填空

对于给定的一行字符串，输出其中每一对小括号里的信息。如果找不到配对的小括号，就输出NONE。

“配对”指的是一个左括号与其右侧最近的右括号的匹配，例如”(a)(b)”里，第一个左括号与第一个右括号配对，第二个左括号与第二个右括号配对。

本题目保证配对的小括号里一定有内容，也就是不会出现”a()b”这样的字符串。

本题目保证配对的小括号不嵌套，也就是不会出现”xy(a(bc)def)z”这样的字符串。

注意，尽管类似”123(ab)cd(ef)gh(ij)k”这样的字符串中也存在”(…(…)…)”的模式，但此时“配对”的小括号没有嵌套，因此是满足题目限制的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import re
exit = 10   #此句没用
n = int(input())
#填空内容应为 pt = "XXXX"，即写一个正则表达式pt
// 在此处补充你的代码
for i in range(n):
    s = input()
    k = re.findall(pt,s)
    if k:
        for x in k:
            print(x, end = " ")
        print("")
    else:
        print("NONE")

  • 输入
    第一行一个整数n，表示输入字符串行数。
    接下来n行里每行一个不包含空格的字符串s。

  • 输出
    输出共n行，每行若干个字符串，相邻字符串间用一个空格分隔，表示每行输入字符串中各个小括号里的内容。

  • 样例输入

1
2
3
4
3
1;!(#234)5@6(78)9(0)*
0(a))(()(bcd)12
)Nothing(
  • 样例输出
1
2
3
#234 78 0
a ( bcd
NONE
  • 提示
    在正则表达式中没有分组时，re.findall返回所有匹配子串构成的列表。

有且只有一个分组时，re.findall返回的是一个子串的列表，每个元素是一个匹配子串中分组对应的内容。

在正则表达式中有超过一个分组时，re.findall返回的是一个元组的列表，每个元组对应于一个匹配的子串，元组里的元素，依次是1号分组、2号分组、3号分组……匹配的内容

  • 提交代码
1
pt = "[(](.*?)[)]"

432b8d97444ad359ec196959b7d8ea99dcf34e2bbc2643c5b327e6ed29bdbb42

005:纸币兑换硬币

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    用一张面值为x元的纸币换面值为y角、z角的硬币，每种硬币至少一枚，问有几种换法？请注意，纸币的单位是元，硬币的单位是角，一元等于10角。

  • 输入
    输入三个正整数x、y和z

  • 输出
    输出一个正整数，为换法的种数

  • 样例输入

样例#1
1 2 5
样例#2
2 2 4
样例#3
3 4 6

  • 样例输出

样例#1
0
样例#2
4
样例#3
2

  • 提示
    枚举y、z可能枚数的全部组合
  • 提交代码
1
2
3
4
5
6
7
8
9
10
11
inputs = input().split()
x = int(inputs[0])*10
y = int(inputs[1])
z = int(inputs[2])
counts = 0

for i in range(1, x // y +1):
    for j in range(1, x // z + 1):
        if i * y + j * z == x:
            counts += 1
print(counts)

ad18cfccb35e13c6240ec08fc75f7e4fdc032834913950a6930516ca93a441e0

006:商品评分

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    购物网站上有许多商品。每个商品都会得到若干用户评分（为1-10的正整数），取这些评分的平均数作为商品总评分。 给出各个商品的名称及它们对应的若干用户评分，请按照商品总评分从高到低的顺序输出商品名称；如果两个商品总评分相同，则用户评分数量多的商品排在前面。

题目保证商品名称各不相同，且不会出现两个总评分与用户评分数量完全相同的商品。 本题目有多组输入数据。

  • 输入
    第一行一个整数n，表示数据组数；
    接下来n组数据，每组数据中：
    第一行一个整数m，表示该组数据中商品个数；
    接下来m行，每行由一个字符串s（只含大小写字母）和若干个正整数（至多50个）组成，分别表示商品名称和用户评分。

  • 输出
    对于每组数据，按题目要求的排序结果，每行输出一个商品名称。

  • 样例输入

    1
    2
    3
    4
    5
    6
    7
    8
    9
    2
    3
    Apple 10 8
    Banana 9 9 9
    Peach 10 9
    3
    Apple 10 8
    Banana 9 
    Peach 9 8

  • 样例输出

    1
    2
    3
    4
    5
    6
    Peach
    Banana
    Apple
    Apple
    Banana
    Peach

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def goodList(good_list: list, line: list):
    for i in range(1, len(line)):
        line[i] = int(line[i])
    good = {}
    good['name'] = line[0]
    good['scores'] = line[1:]
    ave = sum(good['scores']) / len(good['scores'])
    people = len(good['scores'])
    good['information'] = [ave, people]
    good_list.append(good)

    return

def group(num):
    good_li = []
    for i in range(num):
        line = input().split()
        goodList(good_li, line)
        good_li.sort(key=lambda x: x['information'])
    for i in good_li[::-1]:
        print(i['name'])


input()
while True:
    try:
        num = eval(input())
        group(num)
    except:
        break

d6233bd7ebd2278f96851a722e0fee4368a35a24b788179f89adedf50531ea9c

007:物资统计

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    新冠肺炎肆虐全球，中国提供物资支援世界各国。现需统计世界各国总共收到的物资件数。

  • 输入
    第一行输入一个数n，代表中国援外航班数。
    后面是n行，每行代表一个航班。
    每个航班的信息包含一个整数，表示物资数量，以及一个国名。国名不含空格。

  • 输出
    各国的所接收到的物资总件数，按各国名称的字典序输出。

  • 样例输入

    1
    2
    3
    4
    5
    6
    7
    8
    7
    10 USA
    20 Germany
    30 Japan
    40 Korea
    70 Japan
    20 USA
    40 Germany

  • 样例输出

    1
    2
    3
    4
    Germany 60
    Japan 100
    Korea 40
    USA 30

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
x = int(input())
goods = {}
for i in range(x):
    str1 = input().split()
    if str1[1] in goods:
        goods[str1[1]] += int(str1[0])
    else:
        goods[str1[1]] = int(str1[0])

results = []
for x in goods.items():
    results.append(x)
results.sort(key = lambda x: x[0])

for x in range(len(results)):
    print(results[x][0],results[x][1])

572d3e00926e5407e2de4b9e15d5902c7ea2613deb938b146141f51fae0192ee

008:医院负荷

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    一家医院中，同时住院的患者人数称为医院的负荷。

卫生部门获取到了大量的病人住院/出院记录，并希望能据此统计出，在所有时刻单个医院的最大负荷是多少。

住院记录的格式是一行两个正整数p和h，分别表示患者编号和医院编号。

出院记录的格式是一行一个正整数p和一个-1，其中p表示患者编号。

为简便起见，假设每家医院一开始都没有住院患者。

题目保证，每个患者只会住院一次并至多出院一次，且任何患者在出院之前一定会在某家医院住院。（不保证记录结束时，所有患者都已出院）

例如，对于下面的8条记录：

1 1
4 3
3 1
5 1
8 3
3 -1
1 -1
2 1

病人住院/出院过程如下：

①1号患者在1号医院住院，此时1号医院负荷变为1；

②4号患者在3号医院住院，此时3号医院负荷变为1；

③3号患者在1号医院住院，此时1号医院负荷变为2；

④5号患者在1号医院住院，此时1号医院负荷变为3；

⑤8号患者在3号医院住院，此时3号医院负荷变为2；

⑥3号患者出院，由于3号患者之前在1号医院住院，因此1号医院负荷变为2；

⑦1号患者出院，由于1号患者之前在1号医院住院，因此1号医院负荷变为1；

⑧2号患者在1号医院住院，此时1号医院负荷变为2。

在整个过程中，单个医院最大负荷量是3（1号医院在第4条记录时达到该负荷峰值）。

请编写程序来计算医院的最大负荷。

  • 输入
    本题目有多组输入数据。
    第一行一个整数n，表示输入数据的组数；
    接下来共n组数据，每组数据中：
    第一行为一个整数m，表示该组数据中住院/出院记录的条数；
    接下来m行，每行为一条住院/出院记录，格式如上所述。

  • 输出
    对每组输入数据，输出一个整数，表示单个医院曾经达到的最大负荷

  • 样例输入
    2
    8
    1 1
    4 3
    3 1
    5 1
    8 3
    3 -1
    1 -1
    2 1
    1
    1 2

  • 样例输出
    3
    1

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
xxx = int(input())
for ii in range(xxx):
    hospitai = {}
    patient = {}
    sum = int(input())

    fuhe = 0

    for i in range(sum):
        temp = input().split()
        p = temp[0]
        h = temp[1]

        if p not in patient:    #找不到这个病人，需要住院
            patient[p] = h
            if h in hospitai:
                hospitai[h] += 1
            else:
                hospitai[h] = 1
        else:   #找到了这个病人，改病人需要出院
            hospitai[patient[p]] -= 1
            patient[p] = -1

        results = []
        for x in hospitai.items():
            results.append(x)
        results.sort(key=lambda x: -x[1])

        # print(results)

        if fuhe < results[0][1]:
            fuhe = results[0][1]
    print(fuhe)

9e2f4e192cca2730bd510c227c05a299a545050fb00f028601dda22cc03af043

009:矩阵换行求边缘和

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    输入一个整数矩阵，交换其中的两行，然后计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。

  • 输入
    第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。
    接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。
    在接下来是两个整数x,y，表示需要将矩阵的第x行和第y行交换一下。

  • 输出
    输出交换行之后的矩阵的边缘元素和

  • 样例输入
    3 3
    3 4 1
    3 7 1
    2 0 1
    1 2

  • 样例输出
    18

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
line1 = input().split()
m = int(line1[0])
n = int(line1[1])
juzhen = []

for i in range(m):
    hang = input().split()
    juzhen.append(hang)

# print(juzhen)

line1 = input().split()
x = int(line1[0])
y = int(line1[1])

juzhen2 = []
for i in range(m):
    if i == x-1:
        juzhen2.append(juzhen[y-1])
    elif i == y-1:
        juzhen2.append(juzhen[x-1])
    else:
        juzhen2.append(juzhen[i])
# print(juzhen2)

sum = 0

for i in range(m):
    for j in range(n):
        if (i == 0) or (i == m-1) or (j == 0) or (j == n-1):
            sum += int(juzhen2[i][j])
print(sum)

80dbeddbb3e06e11cb1c5a9a3b9ceca97fab741baad9196d12391288deefdd00

010:双重tag里的整数

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    tag是形如
    “A“的字符串，X是一个长度不为0且不超过5的字符串，由大小写字母构成。

““ 和 ““里面的X必须相同。
例如：

xyd 是一个tag
但是 xyd</bc> 不是一个tag。

双重tag形式如下：
“ABC“

X,Y都是一个长度不为0且不超过5的字符串，由大小写字母构成。
““ 和 ““里面的X必须相同，
““和”“里面的Y必须相同。

“B“称为内重tag。”“只和离他最近的”“构成内重tag。
A,B,C是任意长度不为0的字符串。

请找出B中的全部不超过4位的整数。00003 算超过4位。

  • 输入
    若干行。数据保证一个tag内部最多只有一个tag

  • 输出
    对每行，依次输出双重tag中的所有不超过4位且没有前导0的整数。单个的0算没有前导0。如果找不到，就输出NONE

  • 样例输入
    bacbb123aaa 292 bbb 384 j 67477 0 dd 04 05hdc12c</y>def
    k112 3578</c></a>d3 4</y>k</x>def
    k112 3578</c></a>d3 4kdef
    k112 3578</c></a>d3 4def
    k112 3578</c></a>d3 4def
    k112 3578</a></c></B>d3 4def

  • 样例输出
    292 384 0
    12 35 3 4
    12 35 3 4
    12 35
    12 35
    NONE

  • 提示
    读入若干行，需要用 try…except 来判断结束

011:跳水比赛计分

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    有若干个同学参加跳水比赛，每个同学都有若干位老师给他打分。 一共有m条打分记录，每一条记录的格式都是这样的：”id score”，表示编号为id的同学获得了score分。（id和score都是正整数） 现在这m条记录依次送到了你的手上，你想在每一条记录到达的时候，都快速地计算出这个编号为id的同学目前得到的平均分是多少。平均只取整数部分即可，小数部分直接去掉，不要四舍五入。

  • 输入
    第一行，一个整数m。(m <= 100000)
    接下来m行，每行两个正整数代表id和score.

  • 输出
    对每行的 id score, 输出id同学到目前为止的平均分

  • 样例输入
    4
    1 100
    2 90
    2 95
    1 70

  • 样例输出
    100
    90
    92
    85

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
num = int(input())
id_socre_group = {}
id_count_group = {}

for i in range(num):
    temp1 = input().split()
    id = int(temp1[0])
    score = int(temp1[1])

    if id in id_socre_group:
        id_socre_group[id] += score
        id_count_group[id] += 1
    else:
        id_socre_group[id] = score
        id_count_group[id] = 1

    print(int(id_socre_group[id]/id_count_group[id]))

f785e4b4080eba8da831dbebd86c2cc76744af18d5fd0ed35ab82e4447e02860

012:藏头诗

总时间限制: 1000ms 内存限制: 65536kB

  • 描述
    雍正皇帝不能忍受任何人说清朝或者他坏话，以至于他大兴文字狱。因此老百姓书写任何东西都得很小心。诗人写诗也得担心。一些诗人发明了一种奇怪写诗方法，只有TA们朋友圈的人才能看懂。这样的诗统称为藏头诗。

一首藏头诗，是一个N×N的字符矩阵，看起来杂乱无章没啥意思。但是，如果你用特定的顺序读这些字符，你就能看懂。正确的阅读顺序如下面左图所示：

顺着箭头读，你会看到“THISISAVERYGOODPOEMITHINK”,这就有点意思了。

过了一段时间后，诗人们发现，雍正的杀手，血滴子，也学会了读这样的诗。这很危险。所以诗人们发明了新的写诗顺序，如上面右图所示。

诗人想把所有的老写法的诗，都转成新写法的诗歌。请你帮助TA们。

  • 输入
    一共不超过10组数据。
    在每组数据里：
    第一行是一个整数N ( 1 <= N <= 100), 表明诗是一个N×N 的字符矩阵，仅包含大写字母。
    接下来是N行。每行是一个N个字符的字符串。这N行表示一首老写法的诗

  • 输出
    对每组数据，输出新写法的诗。

  • 样例输入
    5
    THSAD
    IIVOP
    SEOOH
    RGETI
    YMINK
    2
    AB
    CD
    4
    ABCD
    EFGH
    IJKL
    MNOP

  • 样例输出
    THISI
    POEMS
    DNKIA
    OIHTV
    OGYRE
    AB
    DC
    ABEI
    KHLF
    NPOC
    MJGD

  • 提交代码

1

013:打印任意年份任意月份的日历

时间限制: 1000ms 内存限制: 65536kB

  • 描述
    给定公元year年month月，打印该月月历

  • 输入
    第一行一个输入整数n，表示有n组数据。
    后面n行，每行一组数据，是两个整数，分别代表year( 0 < year <= 100000）和month（数据合法，1<=month<=12），用空格隔开

  • 输出
    对于每组数据：
    第一行输出月份（英文表示，首字母大写）和年份，用逗号隔开；
    第二行输出星期几， Sun Mon Tue Wed Thu Fri Sat，用\t隔开；
    接下来输出当月日期，日期用\t隔开，第一周缺天直接输出\t。
    （行与行之间无空行，每组数据之间无空行）
    行末多出来\t没有关系
    12个月份的单词是：
    “January”,”February”, “March”, “April”, “May”, “June”, “July”, “August”, “September”, “October”,”November”, “December”

  • 样例输入
    3
    2019 12
    403 5
    23456 7

  • 样例输出
    December,2019
    Sun Mon Tue Wed Thu Fri Sat
    1 2 3 4 5 6 7
    8 9 10 11 12 13 14
    15 16 17 18 19 20 21
    22 23 24 25 26 27 28
    29 30 31
    May,403
    Sun Mon Tue Wed Thu Fri Sat

              1     2     3

    4 5 6 7 8 9 10
    11 12 13 14 15 16 17
    18 19 20 21 22 23 24
    25 26 27 28 29 30 31
    July,23456
    Sun Mon Tue Wed Thu Fri Sat

      1     2     3     4     5

    6 7 8 9 10 11 12
    13 14 15 16 17 18 19
    20 21 22 23 24 25 26
    27 28 29 30 31

  • 提交代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
def is_leap_year(year):
    # 判断是否为闰年
    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        return True
    else:
        return False

def get_num_of_days_in_month(year, month):
    # 给定年月返回月份的天数
    if month in (1, 3, 5, 7, 8, 10, 12):
        return 31
    elif month in (4, 6, 9, 11):
        return 30
    elif is_leap_year(year):
        return 29
    else:
        return 28

def get_total_num_of_day(year, month):
    # 自1800年1月1日以来过了多少天
    days = 0
    for y in range(1800, year):
        if is_leap_year(y):
            days += 366
        else:
            days += 365

    for m in range(1, month):
        days += get_num_of_days_in_month(year, m)

    return days

def get_start_day(year, month):
    # 返回当月1日是星期几，由1800.01.01是星期三推算
    return 3 + get_total_num_of_day(year, month) % 7


# 月份与名称对应的字典
month_dict = {1: 'January', 2: 'February', 3: 'March', 4: 'April', 5: 'May', 6: 'June',
              7: 'July', 8: 'August', 9: 'September', 10: 'October', 11: 'November', 12: 'December'}


def get_month_name(month):
    # 返回当月的名称
    return month_dict[month]


def print_month_title(year, month):
    # 打印日历的首部
    print(get_month_name(month),end="")
    print(",",end="")
    print(year)
    print('Sun\tMon\tTue\tWed\tThu\tFri\tSat')


def print_month_body(year, month):
    '''
    打印日历正文
    格式说明：空两个空格，每天的长度为5
    需要注意的是print加逗号会多一个空格
    '''
    i = get_start_day(year, month)
    if i != 7:
        # print('    ' * i,end="")   # 从星期几开始则空5*几个空格
        for j in range(i):
            print("\t",end="")  # 从星期几开始则空5*几个空格
    for j in range(1, get_num_of_days_in_month(year, month)+1):
        # print('%4d' %j,end="") # 宽度控制，4+1=5
        print('%d' % j,end="\t")  # 宽度控制，4+1=5
        i += 1
        if i % 7 == 0:  # i用于计数和换行
            print()   # 每换行一次行首继续空格
    print()

#   主函数部分
int1 = int(input())
for i in range(int1):
    str1 = input().split()
    year = int(str1[0])
    month = int(str1[1])
    print_month_title(year, month)
    print_month_body(year, month)
文章作者: HibisciDai
文章链接: http://hibiscidai.com/2023/01/14/实用Python程序设计MOOC-期末考试/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 HibisciDai！
学习笔记PythonPythonMOOC
好用、实惠、稳定的梯子,点击这里