SDUT—Python程序设计实验六(字典与集合)

如果你对Python中的字典和集合的使用还不是很熟悉，这两篇文章或许能提供一些帮助：
Python数据容器之字典(dict)
Python数据容器之集合(set)

7-1 sdut-查验身份证

一个合法的身份证号码由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
1
2

现在给定一些身份证号码，请你验证校验码的有效性，并输出有问题的号码。
验证身份证合法性的规则：（1）前17位是否全为数字；（2）最后1位校验码计算准确。

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

输出格式:
按照输入的顺序每行输出1个有问题的身份证号码。
如果所有号码都正常，则输出All passed。

输入样例1:

4
320124198808240056
12010X198901011234
110108196711301866
37070419881216001X
1
2
3
4
5

输出样例1:

12010X198901011234
110108196711301866
37070419881216001X
1
2
3

输入样例2:

2
320124198808240056
110108196711301862
1
2
3

输出样例2:

All passed
1

代码：

W = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
Z = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
M = ['1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2']
dic = dict(zip(Z, M))
flag = 1
n = int(input())
for i in range(n):
    id = input()
    if not id[0: 17].isdigit():
        print(id)
        flag = 0
    else:
        cnt = 0
        for i in range(17):
            cnt += int(id[i])*W[i]
        if dic[cnt % 11] != id[-1]:
            print(id)
            flag = 0
if flag == 1:
    print("All passed")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7-2 sdut-统计两个字符串中相同的字符个数

输入字符串A、字符串B，求在字符串A、字符串B中相同的字符个数。

输入格式:
第一行输入，表示字符串A。
第二行输入，表示字符串B。

输出格式:
在一行内，输出字符串A、B中相同字符的个数。

输入样例:

AEIOU
HELLO World!
1
2

输出样例:
在这里给出相应的输出。例如：

2
1

代码：

st1 = set(input())
st2 = set(input())
print(len(st1 & st2))
1
2
3

7-3 sdut-图的字典表示

现在用PYTHON的数据结构表示图。图中有若干个顶点，每个顶点的表示方式为：顶点名称和该顶点相连的所有的其他顶点的名称，所组成的边的长度。

例如，图中O点表示方式为：{‘O’:{‘A’:2,‘B’:5,‘C’:4}}。
提示：用eval函数处理输入，eval函数具体用法见第8章函数（下）常建的内置函数。

输入格式:
输入多行字符串，每行表示一个顶点。

输出格式:
输出图中所有的顶点数量，边的数量，边的总长度。数值之间有1个空格。

输入样例:

4
{'a':{'b':10,'c':6}}
{'b':{'c':2,'d':7}}
{'c':{'d':10}}
{'d':{}} 
1
2
3
4
5

输出样例:

4 5 35
1

代码：

s1, s2 = 0, 0
n = int(input())
for i in range(n):
    lis = [v2 for v2 in [v1 for v1 in eval(input()).values()][0].values()]
    s1 += len(lis)
    s2 += sum(lis)
print(n, s1, s2)
1
2
3
4
5
6
7

7-4 sdut-分析每队活动投票情况

利用集合分析活动投票情况。
第一小队有五名队员，序号是1,2,3,4,5; 第二小队也有五名队员，序号6,7,8,9,10。
输入一个得票队员的编号的字符串，求第一、二小队没有得票的队员。在一行中输入得票的队员的序列号，用逗号隔开。

输入格式:
在一行中输入得票的队员的序列号，用逗号隔开。

输出格式:
在第一行中输出第一小队没有得票的队员序号，用空格分开；
在第二行中输出第二小队没有得票的队员序号，用空格分开。

输入样例:

1,5,9,3,9,1,1,7,5,7,7,3,3,1,5,7,4,4,5,4,9,5,10,9 
1

输出样例:

2
6 8
1
2

代码：

ls = list(map(int, input().split(',')))
s1, s2 = [], []
for i in range(1, 11):
    if i not in ls:
        if 1 <= i <= 5:
            s1.append(i)
        else:
            s2.append(i)
print(*s1, sep=' ')
print(*s2, sep=' ')
1
2
3
4
5
6
7
8
9
10

7-5 sdut-统计字符在字符串中出现的次数

统计并输出某给定字符在给定字符串中出现的次数。

输入格式:
第一行给出一个以回车结束的字符串（一行少于80个字符）；
第二行输入一个字符。

输出格式:
在一行中输出给定字符在给定字符串中出现的次数。(如果未出现，则输出0）

输入样例:

programming is More fun!
m
1
2

输出样例:

2
1

代码：

s = input()
c = input()
print(s.count(c))
1
2
3

7-6 sdut-输出N天后星期几缩写

已知，今天是星期一。输入一个正整数n，输出n天之后对应的星期几的名称缩写。

星期日 Sun 
星期一 Mon
星期二 Tue
星期三 Wed
星期四 Thu
星期五 Fri
星期六 Sat
1
2
3
4
5
6
7

输入格式:
在一行内输入一个正整数n。

输出格式:
输出n天之后对应的星期几的名称缩写。

输入样例:

1
1

输出样例:

Tue
1

代码：

ls1 = [6, 0, 1, 2, 3, 4, 5]
ls2 = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
dic = dict(zip(ls1, ls2))
n = int(input()) % 7
print(dic[n])
1
2
3
4
5

7-7 sdut-四则运算（用字典实现）

根据输入信息进行四则运算（用字典实现）。
（与c语言的switch语句相比较。）

输入格式:
第1行中输入一个数字a；
第2行中输入一个四帜运算符(+ , - , * , / ) op，
在第3行中输入一个数字b。

输出格式:
在一行中输出 a op b 的运算结果（保留2位小数）。

输入样例1:

7
/
3
1
2
3

输出样例1:

2.33
1

输入样例2:

10
/
0
1
2
3

输出样例2:

divided by zero
1

代码：

dic = {'+': 'x+y', '-': 'x-y', '*': 'x*y', '/': "x/y if y!=0  else 'divided by zero'"}
x = int(input())
opt = input()
y = int(input())
ans = eval(dic[opt])
if type(ans) is not str:
    print("%.2f" % ans)
else:
    print(ans)
1
2
3
4
5
6
7
8
9

7-8 sdut-统计工龄

给定公司N名员工的工龄，按工龄增序输出每个工龄段有多少员工。

输入格式:
首先给出正整数N（≤10^5），即员工总人数；随后给出N个整数，即每个员工的工龄，范围在[0, 50]。

输出格式:
按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。
每项占一行。

输入样例:

8
10 2 0 5 7 2 5 2
1
2

输出样例:
在这里给出相应的输出。例如：

0:1
2:3
5:2
7:1
10:1
1
2
3
4
5

代码：

n = int(input())
ls1 = list(map(int, input().split()))
dic = {}
for it in ls1:
    dic[it] = dic.get(it, 0) + 1
ls2 = sorted(dic.keys())
for i in ls2:
    print("%d:%d" % (i, dic[i]))
1
2
3
4
5
6
7
8

7-9 sdut-字典合并

输入用字符串表示两个字典，输出合并后的字典。字典的键用一个字母或数字表示。
注意：1和‘1’是不同的关键字！

输入格式:
在第一行中输入第一个字典字符串；
在第二行中输入第二个字典字符串。

输出格式:
在一行中输出合并的字典，输出按字典序。
“1” 的 ASCII 码为 49，大于 1，排序时 1 在前，“1” 在后。其它的字符同理。

输入样例1:

{1:3,2:5}
{1:5,3:7} 
1
2

输出样例1:

1:8
2:5
3:7
1
2
3

输入样例2:

{"1":3,1:4}
{"a":5,"1":6}
1
2

输出样例2:

1:4
'1':9
'a':5
1
2
3

代码：

a = dict(eval(input()))
b = dict(eval(input()))
for it in b.keys():
    a[it] = a.get(it, 0) + b[it]
ls1 = list(a.items())
ls1.sort(key=lambda x: ord(x[0]) if type(x[0]) == str else x[0])
ls2 = list(str(dict(ls1)).strip('{}').replace(' ', '').replace('"', "'").split(','))
for it in ls2:
    print(it)
1
2
3
4
5
6
7
8
9

7-10 sdut-两数之和

给定一组整数，还有一个目标数，在给定的一组整数中找到2个数字，使其和为目标数。
如找到，解是唯一的。找不到则显示 “no answer”。
PYTHON实现提示：用一重循环加字典实现。

输入格式:
第1行中给出一组整数。 在第2行输入目标数。

输出格式:
在一行中输出这2个数的下标，用一个空格分开。输出的下标按从小到大排序。
如果找不到，则显示 “no answer”。

输入样例1:

2 7 11 15
9
1
2

输出样例1:

0 1
1

输入样例2:

3 6 9 8 19
10
1
2

输出样例2:

no answer
1

代码：

ls = list(map(int, input().split()))
n = int(input())
flag = 0
for it in ls:
    if n - it in ls:
        print(ls.index(it), ls.index(n - it))
        flag = 1
        break
if flag == 0:
    print("no answer")
1
2
3
4
5
6
7
8
9
10

7-11 sdut-能同时被3、5、7整除的数的个数

求指定区间[a,b]内能同时被3、5、7整除的数的个数。
提示：用集合实现。

输入格式:
在一行中从键盘输入2个正整数a,b（1<=a

输出格式:
在一行输出：大于等于a且小于等于b的区间内、能同时被3、5和7整除的数的个数。

输入样例1:

10 100
1

输出样例1:

0
1

输入样例2:

1000 10000
1

输出样例2:

86
1

代码：

n, m = map(int, input().split())
cnt = 0
for i in range(n, m + 1):
    if i % 105==0:
        cnt += 1
print(cnt)
1
2
3
4
5
6

7-12 sdut-集合相等问题

给定2 个集合S和T，试设计一个判定S和T是否相等的蒙特卡罗算法。
设计一个拉斯维加斯算法，对于给定的集合S和T，判定其是否相等。

输入格式:
输入数据的第一行有1 个正整数n（n≤10000），表示集合的大小。
接下来的2行，每行有n个正整数，分别表示集合S和T中的元素。

输出格式:
将计算结论输出。集合S和T相等，则输出：YES，否则输出：NO。

输入样例:

3
2 3 7
7 2 3
1
2
3

输出样例:

YES
1

代码：

n = int(input())
st1 = set(map(int, input().split()))
st2 = set(map(int, input().split()))
if st1 == st2:
    print("YES")
else:
    print("NO")
1
2
3
4
5
6
7

7-13 sdut-植物与颜色

请定义具有red, orange, yellow, green, blue, violet六种颜色的变量color。
根据输入的颜色名称，输出以下六种植物花朵的颜色：
Rose(red), Poppies(orange), Sunflower(yellow), Grass(green), Bluebells(blue), Violets(violet)。
如果输入的颜色名称不在变量color中，例如，输入：purple，请输出：I don’t know about the color purple.

输入格式:
第1行为颜色的数量n。
接下来有n行字符串每行有一个字符串代表颜色名称，颜色名称最多30个字符。

输出格式:
输出对应颜色的植物名称，例如：Bluebells are blue.
如果输入的颜色名称不在color变量中，例如purple, 请输出I don’t know about the color purple.

输入样例:

3
blue
yellow
purple
1
2
3
4

输出样例:

Bluebells are blue.
Sunflower are yellow.
I don't know about the color purple.
1
2
3

代码：

ls1 = ['red', 'orange', 'yellow', 'green', 'blue', 'violet']
ls2 = ['Rose', 'Poppies', 'Sunflower', 'Grass', 'Bluebells', 'Violets']
dic = dict(zip(ls1, ls2))
n=int(input())
for i in range(n):
    col=input()
    if col in ls1:
        print("%s are %s."%(dic[col],col))
    else:
        print("I don't know about the color %s."%col)
1
2
3
4
5
6
7
8
9
10

7-14 sdut-众数

众数是指在一组数据中，出现次数最多的数。例如：1, 1, 3 中出现次数最多的数为 1，则众数为 1。
给定一组数，你能求出众数吗？

输入格式:
输入数据有多组（数据组数不超过 50）。对于每组数据：
第 1 行输入一个整数 n (1 <= n <= 10000)，表示数的个数。
第 2 行输入 n 个用空格隔开的整数 Ai (0 <= Ai <= 100000)，依次表示每一个数。

输出格式:
对于每组数据，在一行中输出众数以及它出的次数，中间用空格分隔。
数据保证有唯一的众数。

输入样例:

3
1 1 3
5
0 2 3 1 2
1
2
3
4

输出样例:

1 2
2 2
1
2

代码：

while True:
    try:
        n=int(input())
        ls=list(map(int,input().split()))
        num=max(ls,key=ls.count)
        print(num,ls.count(num))
    except EOFError:
        break
1
2
3
4
5
6
7
8

7-15 sdut-查字典

遇到单词不认识怎么办? 查字典啊！
已知字典中有n个单词，现有m个不认识的单词，询问这m个单词是否出现在字典中，如果在字典中就输出其含义，如果不在字典中，就输出：Not found!

输入格式:
含有多组测试用例。
第一行输入n，m (n>=0&&n<=100000&&m>=0&&m<=100000)分别是字典中存在的n个单词，和要查询的m个单词.
紧跟着n行，代表字典中存在的单词及其解释（含义）；
然后m行，要查询的m个单词。
若n=0&&m=0 程序结束

输出格式:
对于待查询的单词，若在字典中存在则输出其解释（含义），不存在输出Not found!

输入样例:

3 2
red: having the colour of blood or fire
green:having the colour of grass or the leaves of most plants and trees
blue:having the colour of a clear sky or the sea/ocean on a clear day
blue
abcded
0 0
1
2
3
4
5
6
7

输出样例:

having the colour of a clear sky or the sea/ocean on a clear day
Not found!
1
2

代码：

while True:
 try:
   dic={}
   n,m=map(int,input().split())
   if n==0 and m==0:
      break
   for i in range(n):
     s1,s2=input().split(':')
     dic[s1]=s2
   for i in range(m):
     col=input()
     if col in dic.keys():
        print(dic[col])   
     else:
        print("Not found!")     
 except EOFError:
    break
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

7-16 sdut-Map(dict)-String–单词和字符鉴别器

读入包含若干个单词的文本数据，将所有内容转换为大写，统计每个单词与该单词的出现次数。此外，还需要统计每个字符及其出现次数（不包括空格）。

输入格式:
若干行的单词，以空格作为分隔符，每行单词数量不定。
遇到一行数据“0000”，读取数据结束。（字符串“0000”不计入上述统计数据）

输出格式:
全部数据读取完成，输出如下信息：
（1）出现次数最多的单词及其出现次数；若次数相同，输出字典序最大的单词。
（2）出现次数最少的单词及其出现次数；若次数相同，输出字典序最小的单词。
（3）每个字母，按A到Z的顺序以及次数。
其中，单词和字母占10个字符位置，左对齐；计数（即：出现次数）占8位，右对齐。

提示：
Java语言，建议使用HashMap存储数据；
Python语言，建议使用dict存储数据。

输入样例:

I would rather have had one breath of her hair
one KISS of her mouth one touch of her hand than an eternity without it
I WOULD rathER haVE HAD oNe BreatH Of Her Hair
ONE kiss of her mouth one touch of her hand than an eternity WITHOUT IT
0000
1
2
3
4
5

输出样例:

ONE              6
AN               2
A               16
B                2
C                2
D                6
E               22
F                6
G                0
H               26
I               12
J                0
K                2
L                2
M                2
N               14
O               20
P                0
Q                0
R               16
S                4
T               20
U                8
V                2
W                4
X                0
Y                2
Z                0
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

代码：

ls_a = [chr(c) for c in range(65, 91)]
ls_b = [0] * 26
dic1, dic2 = {}, dict(zip(ls_a, ls_b))
while True:
    ls1 = list(input().upper().split())
    if ls1 == ["0000"]:
        break
    for it in ls1:
        dic1[it] = dic1.get(it, 0) + 1
    for i in str(ls1):
        if i in dic2:
            dic2[i] += 1
ls2 = sorted(dic1, key=lambda x: (dic1[x], x), reverse=True)
print("%-10s%8d" % (ls2[0], dic1[ls2[0]]))
print("%-10s%8d" % (ls2[-1], dic1[ls2[-1]]))
for k, v in dic2.items():
    print("%-10s%8d" % (k, v))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

因为这学期刚学Python，就当是做个笔记了，代码虽然都能过，但可能不是特别好，有不当的地方欢迎指正，感谢大家的耐心阅读
212丨acc丨2022.11.11