(Python) PAT(Basic Level) Practice 刷题笔记(34-66)

最新推荐文章于 2023-03-07 08:23:15 发布

z.volcano

最新推荐文章于 2023-03-07 08:23:15 发布

阅读量2k

点赞数 3

分类专栏： python PAT 文章标签： python

本文链接：https://blog.csdn.net/weixin_45696568/article/details/119174067

版权

python 同时被 2 个专栏收录

10 篇文章 6 订阅

订阅专栏

PAT

2 篇文章 0 订阅

订阅专栏

我的代码仅能解题，效率不高也不够简洁，欢迎师傅们提出建议，能让我加以改进。

1036 跟奥巴马一起编程 (15 分)

输入格式：

输入在一行中给出正方形边长 N（3≤N≤20）和组成正方形边的某种字符 C，间隔一个空格。

输出格式：

输出由给定字符 C 画出的正方形。但是注意到行间距比列间距大，所以为了让结果看上去更像正方形，我们输出的行数实际上是列数的 50%（四舍五入取整）。

输入样例：

10 a

输出样例：

aaaaaaaaaa
a        a
a        a
a        a
aaaaaaaaaa

a,b=map(str,input().split())
if int(a)%2 ==0 :
    half = int(a)//2
else:
    half = int(a)//2+1
print(int(a)*b)
s=b+" "*(int(a)-2)+b
for i in range(half-2):
    print(s)
print(int(a)*b)

1037 在霍格沃茨找零钱 (20 分)

如果你是哈利·波特迷，你会知道魔法世界有它自己的货币系统 —— 就如海格告诉哈利的：“十七个银西可(Sickle)兑一个加隆(Galleon)，二十九个纳特(Knut)兑一个西可，很容易。”现在，给定哈利应付的价钱 P 和他实付的钱 A，你的任务是写一个程序来计算他应该被找的零钱。

输入格式：

输入在 1 行中分别给出 P 和 A，格式为 Galleon.Sickle.Knut，其间用 1 个空格分隔。这里 Galleon 是 [0, 10
^7 ] 区间内的整数，Sickle 是 [0, 17) 区间内的整数，Knut 是 [0, 29) 区间内的整数。

输出格式：

在一行中用与输入同样的格式输出哈利应该被找的零钱。如果他没带够钱，那么输出的应该是负数。

输入样例1：

10.16.27 14.1.28

输出样例1：

3.2.1

输入样例2：

14.1.28 10.16.27

输出样例2：

-3.2.1

x,y=map(str,input().split())
a,b,c=[],[],[]
s1=s2=s=0
flag=""
for i in x.split("."):
    a.append(int(i))
for i in y.split("."):
    b.append(int(i))
s1=a[0]*17*29+a[1]*29+a[2]
s2=b[0]*17*29+b[1]*29+b[2]
s=s2-s1
if s<0:
    flag+="-"
    s=s1-s2
c.append((s-s%493)//493)
c.append((s-c[0]*493-(s-c[0]*493)%29)//29)
c.append((s-c[0]*493)%29)
flag+=str(c[0])+"."+str(c[1])+"."+str(c[-1])
print(flag)

1038 统计同成绩学生 (20 分)

在这里插入图片描述

n=int(input())
d,flag={},[]
l=list(map(int,input().split()))
for i in l:
    d[i]=d.get(i,0)+1

lt=list(map(int,input().split()))
lt.pop(0)

for i in lt:
    try:
        flag.append(str(d[i]))
    except:
        flag.append('0')
print(" ".join(flag))

1039 到底买不买 (20 分)

在这里插入图片描述

a=list(input())
b=list(input())
n1=n2=0
for i in range(len(b)):
    if b[i] in a:
        a.remove(b[i])
    else:
        n2 += 1
if n2 == 0:
    print("Yes "+str(len(a)))
else:
    print("No "+str(n2))

1040 有几个PAT (25 分)

字符串 APPAPT 中包含了两个单词 PAT，其中第一个 PAT 是第 2 位§，第 4 位(A)，第 6 位(T)；第二个 PAT 是第 3 位§，第 4 位(A)，第 6 位(T)。

现给定字符串，问一共可以形成多少个 PAT？

输入格式：

输入只有一行，包含一个字符串，长度不超过100000 ，只包含 P、A、T 三种字母。

输出格式：

在一行中输出给定字符串中包含多少个 PAT。由于结果可能比较大，只输出对 1000000007 取余数的结果。

输入样例：

APPAPT

输出样例：

2

我自己写的太复杂了，而且还超时，这里参考的是大佬的思路。

思路就是从后往前遍历字符串，遇到T就让x的值加一，遇到A就让y的值加一，遇到P就让z的值加一，xyz分别代表的是字符串T、AT、PAT的数量。

s=list(input())[::-1]

#T AT PAT的数量
x=y=z=0

for i in s:
    if i=="T":
        x+=1
    elif i=="A":
        y+=x
    else:
        z+=y
print(z%1000000007)

1041 考试座位号 (15 分)

在这里插入图片描述

n=int(input())
lt=[]
for i in range(n):
    l=[]
    x,y,z=map(int,input().split())
    l.extend([x,y,z])
    lt.append(l)
m=int(input())
for i in map(int,input().split()):
    for j in lt:
        if j[1]==i:
            print(j[0],j[-1])

1042 字符统计 (20 分)

输入格式：

输入在一行中给出一个长度不超过 1000 的字符串。字符串由 ASCII 码表中任意可见字符及空格组成，至少包含 1 个英文字母，以回车结束（回车不算在内）。

输出格式：

在一行中输出出现频率最高的那个英文字母及其出现次数，其间以空格分隔。如果有并列，则输出按字母序最小的那个字母。统计时不区分大小写，输出小写字母。

输入样例：

This is a simple TEST. There ARE numbers and other symbols 1&2&3…

输出样例：

e 7

s=input().lower()
d,l={},[]
for i in s:
    if i.isalpha():
        d[i]=d.get(i,0)+1
lt=list(d.items())
lt.sort(key=lambda x:x[-1],reverse=True)
max=lt[0][1]
for i in lt:
    if i[1]==max:
        l.append(i[0])
    else:
        break
print(min(l),max)

1043 输出PATest (20 分)

在这里插入图片描述

s=input()
flag=""
a=s.count('P')
b=s.count('A')
c=s.count('T')
d=s.count('e')
e=s.count('s')
f=s.count('t')
for i in range(max(a,b,c,d,e,f)):
    if a:
        flag+='P'
        a-=1
    if b:
        flag+='A'
        b-=1
    if c:
        flag+='T'
        c-=1
    if d:
        flag+='e'
        d-=1
    if e:
        flag+='s'
        e-=1
    if f:
        flag+='t'
        f-=1
print(flag)

1044 火星数字 (20 分)

火星人是以 13 进制计数的：

地球人的 0 被火星人称为 tret。
地球人数字 1 到 12 的火星文分别为：jan, feb, mar, apr, may, jun, jly, aug, sep, oct, nov, dec。
火星人将进位以后的 12 个高位数字分别称为：tam, hel, maa, huh, tou, kes, hei, elo, syy, lok, mer, jou。
例如地球人的数字 29 翻译成火星文就是 hel mar；而火星文 elo nov 对应地球数字 115。为了方便交流，请你编写程序实现地球和火星数字之间的互译。

输入格式：

输入第一行给出一个正整数 N（<100），随后 N 行，每行给出一个 [0, 169) 区间内的数字 —— 或者是地球文，或者是火星文。

输出格式：

对应输入的每一行，在一行中输出翻译后的另一种语言的数字。

输入样例：

4
29
5
elo nov
tam

输出样例：

hel mar
may
115
13

ge=["tret","jan","feb","mar","apr","may","jun","jly","aug","sep","oct","nov","dec"]
shi=["tam", "hel", "maa", "huh", "tou", "kes", "hei", "elo", "syy", "lok", "mer", "jou"]

def encode(n):
    flag=[]
    div=1
    while div:
        div,mod=divmod(n,13)
        flag.append(mod)
        n=div
    flag=flag[::-1]
    if len(flag)==1:
        print(ge[flag[0]])
    else:
        if flag[1]==0:
            print(shi[flag[0]-1])
        else:
            print(shi[flag[0]-1]+" "+ge[flag[1]])

def decode(s):
    l=list(s.split())
    if len(l) == 1:
        if s in ge:
            print(ge.index(s))
        else:
            print(13*(shi.index(s)+1))
    else:
        x=13*(shi.index(l[0])+1)
        y=ge.index(l[1])
        print(x+y)

n=eval(input())
for i in range(n):
    s=input()
    if s.isnumeric():
        encode(eval(s))
    else:
        decode(s)

1045 快速排序 (25 分)

著名的快速排序算法里有一个经典的划分过程：我们通常采用某种方法取一个元素作为主元，通过交换，把比主元小的元素放到它的左边，比主元大的元素放到它的右边。给定划分后的 N 个互不相同的正整数的排列，请问有多少个元素可能是划分前选取的主元？

例如给定 N=5, 排列是1、3、2、4、5。则：

1 的左边没有元素，右边的元素都比它大，所以它可能是主元；
尽管 3 的左边元素都比它小，但其右边的 2 比它小，所以它不能是主元；
尽管 2 的右边元素都比它大，但其左边的 3 比它大，所以它不能是主元；
类似原因，4 和 5 都可能是主元。
因此，有 3 个元素可能是主元。

输入格式：

输入在第 1 行中给出一个正整数 N（≤100000 ）；第 2 行是空格分隔的 N 个不同的正整数，每个数不超过 10^9 。

输出格式：

在第 1 行中输出有可能是主元的元素个数；在第 2 行中按递增顺序输出这些元素，其间以 1 个空格分隔，行首尾不得有多余空格。

输入样例：

5
1 3 2 4 5

输出样例：

3
1 4 5

开始的思路是遍历，然后和左右所有元素进行比较，使用了max()函数和min()函数，然后因为这两个函数超时了。

之后改进代码的时候，发现大佬们的思路更加简洁有效：

n=int(input())
lt=list(map(int,input().split()))
ls=sorted(lt)  #从小到大排序

da=-1
out=[] #用于存放结果
for i in range(n):
    if lt[i] > da:
        da = lt[i]
    if lt[i]==ls[i] and ls[i] >= da:
        out.append(str(lt[i]))
print(len(out))
print(" ".join(out))

1046 划拳 (15 分)

划拳是古老中国酒文化的一个有趣的组成部分。酒桌上两人划拳的方法为：每人口中喊出一个数字，同时用手比划出一个数字。如果谁比划出的数字正好等于两人喊出的数字之和，谁就赢了，输家罚一杯酒。两人同赢或两人同输则继续下一轮，直到唯一的赢家出现。

下面给出甲、乙两人的划拳记录，请你统计他们最后分别喝了多少杯酒。

输入格式：

输入第一行先给出一个正整数 N（≤100），随后 N 行，每行给出一轮划拳的记录，格式为：
甲喊甲划乙喊乙划
其中喊是喊出的数字，划是划出的数字，均为不超过 100 的正整数（两只手一起划）。

输出格式：

在一行中先后输出甲、乙两人喝酒的杯数，其间以一个空格分隔。

输入样例：

5
8 10 9 12
5 10 5 10
3 8 5 12
12 18 1 13
4 16 12 15

输出样例：

1 2

n=int(input())
x,y=0,0
for i in range(n):
    a,b,c,d=map(int,input().split())
    e=a+c
    if b!=e and d!=e or b==d==e:
        pass
    elif b==e and d!=e:
        y+=1
    else:
        x+=1
print(str(x)+" "+str(y))

1047 编程团体赛 (20 分)

在这里插入图片描述

n=int(input())
bian,score=[],[]
for i in range(n):
    s=input().split()
    x=s[0].split("-")
    if x[0] not in bian:
        bian.append(x[0])
        score.append(int(s[1]))
    else:
        score[bian.index(x[0])]+=int(s[1])
print(bian[score.index(max(score))]+" "+str(max(score)))

1048 数字加密 (20 分)

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

输入格式：

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

输出格式：

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

输入样例：

1234567 368782971

输出样例：

3695Q8118

m,n=map(str,input().split())
x=max(len(n),len(m))
m=m.zfill(x)[::-1]
n=n.zfill(x)[::-1]
l,d=[],{10:"J",11:"Q",12:"K"}

for i in range(len(n)):
    if (i+1)%2==1:
        y=(int(m[i])+int(n[i]))%13
        l.append(y)
    elif (i+1)%2==0 and int(n[i])-int(m[i])<0:
        y=int(n[i])-int(m[i])+10
        l.append(y)
    else:
        y=int(n[i])-int(m[i])
        l.append(y)
l.reverse()
for i in l:
    if i < 10:
        print(i,end="")
    else:
        print(d[i],end="")

1049 数列的片段和 (20 分)

给定一个正数数列，我们可以从中截取任意的连续的几个数，称为片段。例如，给定数列 { 0.1, 0.2, 0.3, 0.4 }，我们有 (0.1) (0.1, 0.2) (0.1, 0.2, 0.3) (0.1, 0.2, 0.3, 0.4) (0.2) (0.2, 0.3) (0.2, 0.3, 0.4) (0.3) (0.3, 0.4) (0.4) 这 10 个片段。

给定正整数数列，求出全部片段包含的所有的数之和。如本例中 10 个片段总和是 0.1 + 0.3 + 0.6 + 1.0 + 0.2 + 0.5 + 0.9 + 0.3 + 0.7 + 0.4 = 5.0。

输入格式：

输入第一行给出一个不超过 100000的正整数 N，表示数列中数的个数，第二行给出 N 个不超过 1.0 的正数，是数列中的数，其间以空格分隔。

输出格式：

在一行中输出该序列所有片段包含的数之和，精确到小数点后 2 位。

输入样例：

4
0.1 0.2 0.3 0.4

输出样例：

5.00

这里分析数组中的每一位分别被加了几次，以输入样例为例，第一位被加了4次，第二位被加了(4-1)+3=6次，第三位被加了(4-2)+(3-1)+2=6次，第四位被加了(4-3)+(3-2)+(2-1)+1=4次。

对应次数满足1*4 2*3 3*2 4*1

按照这个规律写代码,不过要注意测试点2，因为浮点数的计算是不精准的，我开始是对计算得到的结果进行精度处理，还是通不过，意识到问题出在前面求和的过程中，上网搜索解决方法，决定使用python中的decimal模块。

from decimal import Decimal
n = int(input())
l = tuple(map(Decimal, input().split()))
he = 0

if n == 1:
    print("{:.2f}".format(sum(l)))
else:
    for i in range(n):
        he+=l[i]*(i+1)*(n-i)
    print("{:.2f}".format(he))

1051 复数乘法 (15 分)

在这里插入图片描述
这题主要难点在于输出，注意0.00以及正负号的把握。

import math

a,b,c,d=map(float,input().split())
r1=a*math.cos(b)
p1=a*math.sin(b)
r2=c*math.cos(d)
p2=c*math.sin(d)

x=r1*r2-p1*p2
y=r1*p2+p1*r2

flag=""
if x>=-0.01 and x<0:
    flag+="0.00"
else:
    flag+="{:.2f}".format(x)
if y>=0:
    flag+="+{:.2f}i".format(y)
elif y>=-0.01 and y<0:
    flag+="+0.00i"
else:
    flag+="{:.2f}i".format(y)
print(flag)

1053 住房空置率 (20 分)

在不打扰居民的前提下，统计住房空置率的一种方法是根据每户用电量的连续变化规律进行判断。判断方法如下：

在观察期内，若存在超过一半的日子用电量低于某给定的阈值 e，则该住房为“可能空置”；
若观察期超过某给定阈值 D 天，且满足上一个条件，则该住房为“空置”。

现给定某居民区的住户用电量数据，请你统计“可能空置”的比率和“空置”比率，即以上两种状态的住房占居民区住房总套数的百分比。

在这里插入图片描述

n,e,d=map(float,input().split())
n=int(n)
d=int(d)
x,y=0,0  #可能空置、空置

for i in range(n):
    l=list(map(float,input().split()))
    k=int(l[0])
    l.pop(0)
    count=0  #次数
    for j in l:
        if j<e: count+=1

    if (k%2==0 and count>k//2) or (k%2==1 and count>=k//2+1):
        if k>d: y+=1
        else: x+=1
print("{:.1f}% {:.1f}%".format(x*100/n,y*100/n))

1054 求平均值 (20 分)

本题的基本要求非常简单：给定 N 个实数，计算它们的平均值。但复杂的是有些输入数据可能是非法的。一个“合法”的输入是 [−1000,1000] 区间内的实数，并且最多精确到小数点后 2 位。当你计算平均值的时候，不能把那些非法的数据算在内。

输入格式：

输入第一行给出正整数 N（≤100）。随后一行给出 N 个实数，数字间以一个空格分隔。

输出格式：

对每个非法输入，在一行中输出 ERROR: X is not a legal number，其中 X 是输入。最后在一行中输出结果：The average of K numbers is Y，其中 K 是合法输入的个数，Y 是它们的平均值，精确到小数点后 2 位。如果平均值无法计算，则用 Undefined 替换 Y。如果 K 为 1，则输出 The average of 1 number is Y。

输入样例1：

7
5 -3.2 aaa 9999 2.3.4 7.123 2.35

输出样例1：

ERROR: aaa is not a legal number
ERROR: 9999 is not a legal number
ERROR: 2.3.4 is not a legal number
ERROR: 7.123 is not a legal number
The average of 3 numbers is 1.38

输入样例2：

2
aaa -9999

输出样例2：

ERROR: aaa is not a legal number
ERROR: -9999 is not a legal number
The average of 0 numbers is Undefined

n=int(input())
lt=list(input().split())

aver,count=0,0
for i in lt:
    try:
        if len(i.split("."))==2 and len(i.split(".")[-1])>2:
            print("ERROR: {} is not a legal number".format(i))
        elif -1000<=eval(i)<=1000:
            aver+=eval(i)
            count+=1
        else:
            print("ERROR: {} is not a legal number".format(i))
    except:
        print("ERROR: {} is not a legal number".format(i))
if count==0:
    print("The average of 0 numbers is Undefined")
elif count==1:
    print("The average of 1 number is {:.2f}".format(aver))
else:
    print("The average of {} numbers is {:.2f}".format(count,aver/count))

1056 组合数的和 (15 分)

给定 N 个非 0 的个位数字，用其中任意 2 个数字都可以组合成 1 个 2 位的数字。要求所有可能组合出来的 2 位数字的和。例如给定 2、5、8，则可以组合出：25、28、52、58、82、85，它们的和为330。

输入格式：

输入在一行中先给出 N（1 < N < 10），随后给出 N 个不同的非 0 个位数字。数字间以空格分隔。

输出格式：

输出所有可能组合出来的2位数字的和。

输入样例：

3 2 8 5

输出样例：

330

n=[]
count=0
for i in input().split():
    n.append(int(i))
n.pop(0)
for i in range(len(n)):
    count+=n[i]
count=count*(len(n)-1)*11
print(count)

1057 数零壹 (20 分)

给定一串长度不超过 100000的字符串，本题要求你将其中所有英文字母的序号（字母 a-z 对应序号 1-26，不分大小写）相加，得到整数 N，然后再分析一下 N 的二进制表示中有多少 0、多少 1。例如给定字符串 PAT (Basic)，其字母序号之和为：16+1+20+2+1+19+9+3=71，而 71 的二进制是 1000111，即有 3 个 0、4 个 1。

输入格式：

输入在一行中给出长度不超过 100000、以回车结束的字符串。

输出格式：

在一行中先后输出 0 的个数和 1 的个数，其间以空格分隔。注意：若字符串中不存在字母，则视为 N 不存在，也就没有 0 和 1。

输入样例：

PAT (Basic)

输出样例：

3 4

s=input().upper()

n,x,y=0,0,0
for i in s:
    if i.isalpha():
        n+=ord(i)-64
n=bin(n)[2:]

for i in n:
    if i=="0":x+=1
    else:y+=1
if n=="0":
    print("0 0")
else:
    print(str(x)+" "+str(y))

1058 选择题 (20 分)

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

输入格式：

输入在第一行给出两个正整数 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

n,m=map(int,input().split())   #学生人数  选择题个数

man,true_shu,answer=[],[],[]
for i in range(m):  #正确答案
    l=list(map(str,input().split()))
    man.append(l[0]) #满分值
    true_shu.append(l[2]) #正确选项个数
    answer.append(l[3:]) #选项答案

d={}  #统计错误次数
score=[] #学生的分数
for i in range(n):  #答题情况
    flag,he=0,0
    for j in input().split(') ('):
        j=j.replace("(","").replace(")","")
        if j[0] != true_shu[flag] or list(j[2:].split()) != answer[flag]:
            d[flag+1]=d.get(flag+1,0)+1
        else:
            he += int(man[flag])
        flag+=1
    score.append(he)
lt=list(d.items())
lt.sort(key=lambda x:(-x[1],x[0]),reverse=False)
for i in range(n): print(score[i])

s=""
if len(lt):
    s+=str(lt[0][1])+" "
    for i in lt:
        if i[1] == lt[0][1]:
            s+=str(i[0])+" "
    print(s.strip(" "))
else:
    print("Too simple")

1061 判断题 (15 分)

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

输入格式：

输入在第一行给出两个不超过 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())
score,true=[],[]
for i in input().split():
    score.append(int(i))
for i in input().split():
    true.append(int(i))

for i in range(n):
    k=0
    he=0
    for j in input().split():
        if int(j)==true[k]:
            he += score[k]
        k += 1
    print(he)

1063 计算谱半径 (20 分)

在这里插入图片描述

n=int(input())

flag=[]

for i in range(n):
    a,b=map(int,input().split())
    flag.append((a**2+b**2)**0.5)
print("{:.2f}".format(max(flag)))

1064 朋友数 (20 分)

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

在这里插入图片描述

n=int(input())
l=list(map(str,input().split()))
d={}
flag=[]

for i in l:
    he=0
    for j in i:
        he+=int(j)
    d[he]=d.get(he,0)+1
lt=list(d.items())
lt.sort(key=lambda x:x[0],reverse=False)
print(len(lt))
for i in lt:
    flag.append(str(i[0]))
print(" ".join(flag))

1065 单身狗 (25 分)

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

输入第一行给出一个正整数 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

ban={}
for i in range(int(input())):
    a,b=map(str,input().split())
    ban[a]=b

n=int(input())
l=set(map(str,input().split()))   #集合的查询速度比列表更快
gou=l.copy()
for i in l:
    if i in ban:
        if ban[i] in l:
            gou.remove(i)
            gou.remove(ban[i])
gou=list(gou)
gou.sort()
print(len(gou))
if len(gou)==0:
    pass
else:
    print(" ".join(gou))

1066 图像过滤 (15 分)

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

输入格式：

输入在第一行给出一幅图像的分辨率，即两个正整数 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

m,n,a,b,r=map(int,input().split())

for i in range(m):
    l=[]
    for j in map(int,input().split()):
        if a<=j<=b:
            l.append(str(r).zfill(3))
        else:
            l.append(str(j).zfill(3))
    print(" ".join(l))