作业2-03-python的组合数据类型

1048 数字加密

问题描述：

本题要求实现一种数字加密方法。首先固定一个加密用正整数 A，对任一正整数 B，将其每 1 位数字与 A 的对应位置上的数字进行以下运算：对奇数位，对应位的数字相加后对 13 取余——这里用 J 代表 10、Q 代表 11、K 代表 12；对偶数位，用 B 的数字减去 A 的数字，若结果为负数，则再加 10。这里令个位为第 1 位。

输入说明：

输入在一行中依次给出 A 和 B，均为不超过 100 位的正整数，其间以空格分隔。

输出说明：

在一行中输出加密后的结果。

输入样列：

1234567 368782971

输出样列：

3695Q8118

代码：

因为个位为第 1 位所以可以讲A和B都进行转置
x = x[::-1]
y = y[::-1]
同时对长度小的那一位自动补0保证长度相等方便后面的计算
接下来就是对每一位奇偶判断各自操作即可

a = input().split()
str1 = ""
str2 = ""
if len(a[0]) >= len(a[1]):
    x = a[0]
    y = (len(a[0]) - len(a[1])) * '0' + a[1]
else:
    x = a[0]
    y = a[1][len(a[1]) - len(a[0]):]
    str1 = a[1][:len(a[1]) - len(a[0])]
x = x[::-1]
y = y[::-1]
for i in range(len(x)):
    if (i + 1) % 2 != 0:
        n = (int(x[i]) + int(y[i])) % 13
        if n == 10:
            str2 = 'J' + str2
        elif n == 11:
            str2 = 'Q' + str2
        elif n == 12:
            str2 = 'K' + str2
        else:
            str2 = str(n) + str2
    else:
        n = int(y[i]) - int(x[i])
        if n < 0:
            n += 10
        str2 = str(n) + str2
print(str1 + str2)

1053 住房空置率

问题描述：

在不打扰居民的前提下，统计住房空置率的一种方法是根据每户用电量的连续变化规律进行判断。判断方法如下：
在观察期内，若存在超过一半的日子用电量低于某给定的阈值 e，则该住房为“可能空置”；
若观察期超过某给定阈值 D 天，且满足上一个条件，则该住房为“空置”。
现给定某居民区的住户用电量数据，请你统计“可能空置”的比率和“空置”比率，即以上两种状态的住房占居民区住房总套数的百分比。

输入说明：

输入第一行给出正整数 N（≤1000），为居民区住房总套数；正实数 e，即低电量阈值；正整数 D，即观察期阈值。随后 N 行，每行按以下格式给出一套住房的用电量数据： K E1 E2… EK其中 K 为观察的天数，E i 为第 i 天的用电量。

输出说明：

在一行中输出“可能空置”的比率和“空置”比率的百分比值，其间以一个空格分隔，保留小数点后 1 位。

输入样列：

5 0.5 10
6 0.3 0.4 0.5 0.2 0.8 0.6
10 0.0 0.1 0.2 0.3 0.0 0.8 0.6 0.7 0.0 0.5
5 0.4 0.3 0.5 0.1 0.7
11 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1
11 2 2 2 1 1 0.1 1 0.1 0.1 0.1 0.1

输出样列：

40.0% 20.0%

代码：

n, e, d = input().split()
n = int(n)
num1, num2 = 0, 0
for i in range(n):
    lst = list(map(float, input().split()))
    cnt = 0
    for j in lst[1:]:
        if j < float(e):
            cnt += 1
    if 2.0 * cnt > lst[0] and lst[0] <= float(d):
        num1 += 1
    elif 2.0 * cnt > lst[0] and lst[0] > float(d):
        num2 += 1
print("%.1f%% %.1f%%" % (100 * num1 / n, 100 * num2 / n))

1055 集体照

问题描述：

拍集体照时队形很重要，这里对给定的 N 个人 K 排的队形设计排队规则如下：
每排人数为 N/K（向下取整），多出来的人全部站在最后一排；
后排所有人的个子都不比前排任何人矮；
每排中最高者站中间（中间位置为 m/2+1，其中 m 为该排人数，除法向下取整）；
每排其他人以中间人为轴，按身高非增序，先右后左交替入队站在中间人的两侧（例如5人身高为190、188、186、175、170，则队形为175、188、190、186、170。这里假设你面对拍照者，所以你的左边是中间人的右边）；
若多人身高相同，则按名字的字典序升序排列。这里保证无重名。
现给定一组拍照人，请编写程序输出他们的队形。

输入说明：

每个输入包含 1 个测试用例。每个测试用例第 1 行给出两个正整数 N（≤104，总人数）和 K（≤10，总排数）。随后 N 行，每行给出一个人的名字（不包含空格、长度不超过 8 个英文字母）和身高（[30, 300] 区间内的整数）。

输出说明：

输出拍照的队形。即K排人名，其间以空格分隔，行末不得有多余空格。注意：假设你面对拍照者，后排的人输出在上方，前排输出在下方。

输入样列：

10 3
Tom 188
Mike 170
Eva 168
Tim 160
Joe 190
Ann 168
Bob 175
Nick 186
Amy 160
John 159

输出样列：

Bob Tom Joe Nick
Ann Mike Eva
Tim Amy John

代码：

题目要求若多人身高相同，则按名字的字典序升序排列，所以仅对身高进行排序是不够的，一开始这里错了好几次。可以重写sorted()的key,利用lambda讲升高作为第一关键词，名字作为第二关键词
list.append(obj)是在尾部插入
list.insert(index, obj)是在index下标的位置插入obj元素
两者交替使用可以做到题目要求的身高非增序，先右后左交替入队

num, k = list(map(int, input().split()))
person = []
for i in range(num):
    person.append(input().split())
order = sorted(person, key=lambda x: (-int(x[1]), x[0]))
hang, last = num // k, num // k + num % k
b = []
sum = 0
for i in range(num):
    if sum % 2 == 0:
        b.append(order[i][0])
    else:
        b.insert(0, order[i][0])
    sum += 1
    if sum == last:
        print(" ".join(b))
        last = hang
        b = []
        sum = 0

1058 选择题

问题描述：

批改多选题是比较麻烦的事情，本题就请你写个程序帮助老师批改多选题，并且指出哪道题错的人最多。

输入说明：

输入在第一行给出两个正整数 N（≤ 1000）和 M（≤ 100），分别是学生人数和多选题的个数。随后 M 行，每行顺次给出一道题的满分值（不超过 5 的正整数）、选项个数（不少于 2 且不超过 5 的正整数）、正确选项个数（不超过选项个数的正整数）、所有正确选项。注意每题的选项从小写英文字母 a 开始顺次排列。各项间以 1 个空格分隔。最后 N 行，每行给出一个学生的答题情况，其每题答案格式为 (选中的选项个数 选项1 ……)，按题目顺序给出。注意：题目保证学生的答题情况是合法的，即不存在选中的选项数超过实际选项数的情况。

输出说明：

按照输入的顺序给出每个学生的得分，每个分数占一行。注意判题时只有选择全部正确才能得到该题的分数。最后一行输出错得最多的题目的错误次数和编号（题目按照输入的顺序从 1 开始编号）。如果有并列，则按编号递增顺序输出。数字间用空格分隔，行首尾不得有多余空格。如果所有题目都没有人错，则在最后一行输出 Too simple。

输入样列：

3 4
3 4 2 a c
2 5 1 b
5 3 2 b c
1 5 4 a b d e
(2 a c) (2 b d) (2 a c) (3 a b e)
(2 a c) (1 b) (2 a b) (4 a b d e)
(2 b d) (1 e) (2 b c) (4 a b c d)

输出样列：

3
6
5
2 2 3 4

代码：

有一说一这个切片操作是真的厉害
string = string[1:-1]
string = string.split(') (')

n,m = map(int,input().split())
value_list, error_list, answer_list = [], [], []

for i in range(m):
    error_list.append(0)
    string = input().split()
    value_list.append(string[0])
    answer_list.append(string[2:])

for i in range(n):
    sum = 0
    string = input()
    string = string[1:-1]
    string = string.split(') (')
    for j in range(m):
        my = ' '.join(answer_list[j])
        if my == string[j]:
            sum += int(value_list[j])
        else:
            error_list[j] += 1
    print(sum)

max_value = max(error_list)
if max_value == 0:
    print("Too simple")
else:
    print(max_value, end='')
    for i in range(m):
        if error_list[i] == max_value:
            print(' ' + str(i + 1), end="")

1060 爱丁顿数

问题描述：

英国天文学家爱丁顿很喜欢骑车。据说他为了炫耀自己的骑车功力，还定义了一个“爱丁顿数” E ，即满足有 E 天骑车超过 E 英里的最大整数 E。据说爱丁顿自己的 E 等于87。
现给定某人 N 天的骑车距离，请你算出对应的爱丁顿数 E（≤N）。

输入说明：

输入第一行给出一个正整数 N (≤105)，即连续骑车的天数；第二行给出 N 个非负整数，代表每天的骑车距离。

输出说明：

在一行中给出 N 天的爱丁顿数。

输入样列：

10
6 7 6 9 3 10 8 2 7 8

输出样列：

6

代码：

对骑车的距离进行降序排序，顺序遍历判断当天的骑行距离是否大于天数即可。可以算是一道思维题了。当初我还想用二分＋树状数组来做，属实铁nt

n = int(input())
ls = list(map(int, input().split()))
ls = sorted(ls, reverse=True)
E = 0
for i in range(n):
    if ls[i] > E + 1:
        E += 1
print(E)

1061 判断题

问题描述：

判断题的评判很简单，本题就要求你写个简单的程序帮助老师判题并统计学生们判断题的得分。

输入说明：

输入在第一行给出两个不超过 100 的正整数 N 和 M，分别是学生人数和判断题数量。第二行给出 M 个不超过 5 的正整数，是每道题的满分值。第三行给出每道题对应的正确答案，0 代表“非”，1 代表“是”。随后 N 行，每行给出一个学生的解答。数字间均以空格分隔。

输出说明：

按照输入的顺序输出每个学生的得分，每个分数占一行。

输入样列：

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

输出样列：

13
11
12

代码：

n, m = map(int, input().split())
lst = list(map(int, input().split()))
ans = list(input().split())
for i in range(n):
    sum = 0
    t = list(input().split())
    k = 0
    for j in t:
        if j == ans[k]:
            sum += lst[k]
        k += 1
    print(sum)

1064 朋友数

问题描述：

如果两个整数各位数字的和是一样的，则被称为是“朋友数”，而那个公共的和就是它们的“朋友证号”。例如 123 和 51 就是朋友数，因为 1+2+3 = 5+1 = 6，而 6 就是它们的朋友证号。给定一些整数，要求你统计一下它们中有多少个不同的朋友证号。

输入说明：

输入第一行给出正整数 N。随后一行给出 N 个正整数，数字间以空格分隔。题目保证所有数字小于 104。

输出说明：

首先第一行输出给定数字中不同的朋友证号的个数；随后一行按递增顺序输出这些朋友证号，数字间隔一个空格，且行末不得有多余空格。

输入样列：

8
123 899 51 998 27 33 36 12

输出样列：

4
3 6 9 26

代码：

题目说这么一大推其实就是求每个数的各位之和，好像并不用判断是否出现两次以上，或者说数据太弱了？

n = int(input())
a = input().split()
sum1 = []
for i in a:
    b = 0
    for j in i:
        b += int(j)
    if b not in sum1:
        sum1.append(b)
sum1.sort()
print(len(sum1))
sum1 = map(str, sum1)
print(" ".join(sum1))

1065 单身狗

问题描述：

“单身狗”是中文对于单身人士的一种爱称。本题请你从上万人的大型派对中找出落单的客人，以便给予特殊关爱。

输入说明：

输入第一行给出一个正整数 N（≤ 50 000），是已知夫妻/伴侣的对数；随后 N 行，每行给出一对夫妻/伴侣——为方便起见，每人对应一个 ID 号，为 5 位数字（从 00000 到 99999），ID 间以空格分隔；之后给出一个正整数 M（≤ 10 000），为参加派对的总人数；随后一行给出这 M 位客人的 ID，以空格分隔。题目保证无人重婚或脚踩两条船。

输出说明：

首先第一行输出落单客人的总人数；随后第二行按 ID 递增顺序列出落单的客人。ID 间用 1 个空格分隔，行的首尾不得有多余空格。

输入样列：

3
11111 22222
33333 44444
55555 66666
7
55555 44444 10000 88888 22222 11111 23333

输出样列：

5
10000 23333 44444 55555 88888

代码：

这道题思路很简单但是好像python一般的写法会T，网上拉了一个代码过来，pta对python还是不太友好

n = int(input())
cp_dict = {}
for i in range(n):
    a, b = input().split()
    cp_dict[a] = b

key = cp_dict.keys()
m = input()
guest_list = input().split()
guest_set = set(guest_list)
for guest in guest_set:
    if guest in key and cp_dict[guest] in guest_set:
        guest_list.remove(guest)
        guest_list.remove(cp_dict[guest])
guest_list.sort()
dog = len(guest_list)
print(dog)
if guest_list:
    print(" ".join(guest_list))

1066 图像过滤

问题描述：

图像过滤是把图像中不重要的像素都染成背景色，使得重要部分被凸显出来。现给定一幅黑白图像，要求你将灰度值位于某指定区间内的所有像素颜色都用一种指定的颜色替换。

输入说明：

输入在第一行给出一幅图像的分辨率，即两个正整数 M 和 N（0<M,N≤500），另外是待过滤的灰度值区间端点 A 和 B（0≤A<B≤255）、以及指定的替换灰度值。随后 M 行，每行给出 N 个像素点的灰度值，其间以空格分隔。所有灰度值都在 [0, 255] 区间内。

输出说明：

输出按要求过滤后的图像。即输出 M 行，每行 N 个像素灰度值，每个灰度值占 3 位（例如黑色要显示为 000），其间以一个空格分隔。行首尾不得有多余空格。

输入样列：

3 5 100 150 0
3 189 254 101 119
150 233 151 99 100
88 123 149 0 255

输出样列：

003 189 254 000 000
000 233 151 099 000
088 000 000 000 255

代码：

400ms的时限，能跑到329ms、268ms、302ms还会T，事实证明pta的评测机是真的抖。这题按我这样写可能会T，多交几次就过了，概率过题，也可能是我代码写的太烂了QAQ。

lst = list(input().split())
for i in range(int(lst[0])):
    t = input().split()
    x = []
    for j in t:
        if int(lst[2]) <= int(j) <= int(lst[3]):
            x.append(lst[4].rjust(3, '0'))
        else:
            x.append(j.rjust(3, '0'))
    print(' '.join(x))

1069 微博转发抽奖

问题描述：

小明 PAT 考了满分，高兴之余决定发起微博转发抽奖活动，从转发的网友中按顺序每隔 N 个人就发出一个红包。请你编写程序帮助他确定中奖名单。

输入说明：

输入第一行给出三个正整数 M（≤ 1000）、N 和 S，分别是转发的总量、小明决定的中奖间隔、以及第一位中奖者的序号（编号从 1 开始）。随后 M 行，顺序给出转发微博的网友的昵称（不超过 20 个字符、不包含空格回车的非空字符串）。
注意：可能有人转发多次，但不能中奖多次。所以如果处于当前中奖位置的网友已经中过奖，则跳过他顺次取下一位。

输出说明：

按照输入的顺序输出中奖名单，每个昵称占一行。如果没有人中奖，则输出 Keep going…。

输入样列1：

9 3 2
Imgonnawin!
PickMe
PickMeMeMeee
LookHere
Imgonnawin!
TryAgainAgain
TryAgainAgain
Imgonnawin!
TryAgainAgain

输出样列1：

PickMe
Imgonnawin!
TryAgainAgain

输入样列2：

2 3 5
Imgonnawin!
PickMe

输出样列2：

Keep going…

代码：

M, N, S = map(int, input().split())
flag = {}
count = 0
if S > M:
    print("Keep going...")
else:
    for i in range(1, M + 1):
        t = input()
        if i == S:
            flag[t] = 1
        if i > S:
            count += 1
            if count == N:
                if t not in flag:
                    flag[t] = 1
                    count = 0
                else:
                    count -= 1
    for i in flag:
        print(i)

1083 是否存在相等的差

问题描述：

给定 N 张卡片，正面分别写上 1、2、……、N，然后全部翻面，洗牌，在背面分别写上 1、2、……、N。将每张牌的正反两面数字相减（大减小），得到 N 个非负差值，其中是否存在相等的差？。

输入说明：

输入第一行给出一个正整数 N（2 ≤ N ≤ 10 000），随后一行给出 1 到 N 的一个洗牌后的排列，第 i 个数表示正面写了 i 的那张卡片背面的数字。

输出说明：

按照“差值 重复次数”的格式从大到小输出重复的差值及其重复的次数，每行输出一个结果。

输入样列：

8
3 5 8 6 2 1 4 7

输出样列：

5 2
3 3
2 2

代码：

n = int(input())
lst = list(map(int, input().split()))
dir = {}
j = 1
for i in lst:
    x = abs(i - j)
    if x in dir:
        dir[x] += 1
    else:
        dir[x] = 1
    j+=1
lt = sorted(dir, reverse=True)
for i in lt:
    if dir[i] != 1:
        print(i, dir[i])

1087 有多少不同的值

问题描述：

当自然数 n 依次取 1、2、3、……、N 时，算式 ⌊n/2⌋+⌊n/3⌋+⌊n/5⌋ 有多少个不同的值？（注：⌊x⌋ 为取整函数，表示不超过 x 的最大自然数，即 x 的整数部分。）。

输入说明：

输入给出一个正整数 N（2≤N≤104 ）。

输出说明：

在一行中输出题面中算式取到的不同值的个数。

输入样列：

2017

输出样列：

1480

代码：

set简单粗暴

s = set()
n = int(input())
for i in range(1, n + 1):
    s.add((i // 2 + i // 3 + i // 5))
print(len(s))

1093 字符串A+B

问题描述：

给定两个字符串 A 和 B，本题要求你输出 A+B，即两个字符串的并集。要求先输出 A，再输出 B，但重复的字符必须被剔除。

输入说明：

输入在两行中分别给出 A 和 B，均为长度不超过 106 的、由可见 ASCII 字符 (即码值为32~126)和空格组成的、由回车标识结束的非空字符串。

输出说明：

在一行中输出题面要求的 A 和 B 的和。

输入样列：

This is a sample test
to show you_How it works

输出样列：

This ampletowyu_Hrk

代码：

l = input() + input()
st = set(l)
for i in l:
    if i in st:
        st.remove(i)
        print(i, end='')