PTA | python期末考试复习题

"""
编写一个凯撒密码加密程序，接收用户输入的文本和密钥k，对明文中的字母a-z和字母A-Z替换为其后第k个字母。

输入格式:
接收两行输入，第一行为待加密的明文，第二行为密钥k。

输出格式:
输出加密后的密文。
"""
'''
n = input()
x = int(input())
y = ''

for i in n:
    if i.isalpha():
        temp = ord(i) + x
        if chr(temp).isalpha():
            y += chr(temp)
        else:
            y += chr(temp - 26)
    else:
        y += i

print(y)

'''
'''
小丽对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0)，在 1 到 40 中这样的数包括 
1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574。 请问，在 1 到 n 中，所有这样的数的和是多少?

输入格式:
输入一行包含一个整数 n。

输出格式:
输出一行，包含一个整数，表示满足条件的数的和。
'''
'''
n = int(input())
c = 0
for i in range(1,n + 1):
    if str(i).count('2') or str(i).count('0') or str(i).count('1') or str(i).count('9'):
        c += i

print(c)
'''
'''
科研工作者经常要向不同的期刊投稿。但不同期刊的参考文献的格式往往各不相同。
有些期刊要求参考文献所发表的期刊名必须采用缩写形式，否则直接拒稿。现对于给定的期刊名，要求按以下规则缩写：
（1）长度不超过4的单词不必缩写；
（2）长度超过4的单词仅取前4个字母，但其后要加“.”；
（3）所有字母都小写。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试输入一个包含大小写字母和空格的字符串（长度不超过85），单词由若干字母构成，单词之间以一个空格间隔。

输出格式:
对于每组测试，在一行上输出缩写后的结果，单词之间以一个空格间隔。
'''
'''
n = int(input())
for i in range(n):
    l = 0
    m = input().split()
    for j in m:
        l += 1
        j = j.lower()
        if l>=1 and l<len(m):
            if len(j) > 4:
                print(j[0:4:1]+'.'+' ',end='')
            else:
                print(j+' ',end='')
        else:
            if len(j) > 4:
                print(j[0:4:1]+'.')
            else:
                print(j)
'''
'''
编写一个程序，接受用户输入的一行英文句子（假设该句子仅由英文单词及空格构成，不包括逗号等符号），统计并输出该行句子包含的单词个数及单词的平均长度。

输入格式:
单词1 单词2 .... 单词n

输出格式:
单词个数,单词平均长度（保留两位小数）
'''
'''
n = input().split()
sum = 0
for i in n:
    sum += len(i)
print(f"{len(n)},{sum/len(n):.2f}")
'''

'''
编写程序，用于计算有n(1<n<10)个字符串中最长的字符串的长度。前导空格不要计算在内！

输入格式:
在第一行中输入n,接下的每行输入一个字符串

输出格式:
在一行中输出最长的字符串的长度
'''
'''
n = int(input())
z = 0
for i in range(n):
    x = input()
    x = x.strip()
    y = len(x)
    if z < y:
        z = y
print('length=%d'%z)

'''
'''

输入一行字符，以回车结束，统计其中单词的个数。单词是中间没有空格的字符序列，各单词之间用空格分隔，单词间空格数可以是多个。

输入格式:
在一行中输入字符

输出格式:
在一行中输出单词的数量
'''
'''
n = input().split()
k = 0
for i in n:
    k += 1

print("count = %d"%k)
'''
'''
随机输入一个字符串，把最左边的10个不重复的英文字母（不区分大小写）挑选出来。
如没有10个英文字母，显示信息“not found”

输入格式:
在一行中输入字符串

输出格式:
在一行中输出最左边的10个不重复的英文字母或显示信息“not found"
'''
'''
编写程序，实现下述功能：

从键盘读入矩形的长，以厘米为单位，应为小数；
从键盘读入矩形的宽，以厘米为单位，应为小数；
使用勾股定理计算对角线的长度并输出，保留1位小数。
'''
'''
x = float(input())
y = float(input())
print("对角线长度为:%.1fcm." % ((x ** 2 + y ** 2) ** 0.5))
'''
'''
给定一组整数，还有一个目标数，在给定这组整数中找到两个数字，使其和为目标数，如找到，解是唯一的。找不到则显示 "no answer"。输出的下标按从小到大排序。用一重循环加字典实现。

输入格式:
在一行中给出这组数。
在下一行输入目标数

输出格式:
在一行中输出这两个数的下标，用一个空格分开。
'''
'''
n = map(int,input().split(','))
n = list(n)
m = int(input())

for i in range(0,len(n)):
    for j in range(i + 1,len(n)):
        if n[i] + n[j] == m:
            print("%d %d"%(i,j))
            exit(0)

print('no answer')
'''
'''
输入一个1到7的数字，输出对应的星期名的缩写。
1 Mon
2 Tue
3 Wed
4 Thu
5 Fri
6 Sat
7 Sun

输入格式:
输入1到7之间数字

输出格式:
输出对应的星期名的缩写
'''
'''
m = {}
m[1] ='Mon'
m[2] ='Tue'
m[3] ='Wed'
m[4] ='Thu'
m[5] ='Fri'
m[6] ='Sat'
m[7] ='Sun'

n = int(input())

print(m[n])
'''
'''
生日悖论，指如果一个房间里有23个或23个以上的人，那么至少有两个人的生日相同的概率要大于50%。尝试编程验证。

验证方法提示：使用从1到365的整数代表生日。测试n次，每次生成23个随机数，随机数的范围从1到365(包括365)。
然后查看有无重复的生日。
最后算出重复的比率。

输入格式:
随机数种子x 测试次数n

注意：需将x转换为整数型再进行设置。

输出格式:
rate=算出的比率，比率保留2位小数
'''
'''
import random
x, n = map(int, input().split())
random.seed(x)
count = 0
for i in range(n):
    s = set()    	#创建空集合只能用set()
    for j in range(23):
        a = random.randint(1, 365)
        s.add(a)
    if len(s) != 23:
        count = count + 1
rate = count / n
print("rate={:.2f}".format(rate))
'''
'''
输入一个以换行结束的字符串，统计并输出字符串中小写元音字母的个数(小写元音字母: 'a','e','i','o','u')。

输入格式:
在一行中输入字符串

输出格式:
在一行中输出字符串中小写元音字母的个数
'''
'''
n = input()
s = []
s.append('a')
s.append('e')
s.append('i')
s.append('o')
s.append('u')
x = 0
for i in range(0,len(n)):
    if n[i] in s:
        x += 1
print(x)
'''
'''
现需要统计若干段文字(英文)中的不同单词数量。
如果不同的单词数量不超过10个，则将所有单词输出(按字母顺序)，否则输出前10个单词。
'''
'''
str = []               
a = input()
while a != "!!!!!":
    str += [" "]           #将行末区分开
    str += a
    a = input()            #输入文本
count = []                 #统计单词
strCount = len(str)
start = end = 0
str.insert(0, " ")
str.insert(len(str), " ")
#去除文本中的空格数并统计单词个数
flag = 0
for i in range(len(str)):
    if str[i - 1] == " " and str[i] != " ":
        flag += 1
        start = i
    if str[i] != " " and str[i + 1] == " ":
        flag += 1
        end = i
    if flag == 2:
        sub = str[start:end + 1]
        sub = "".join(sub)
        flag = 0
        if sub not in count:
            count += [sub]                     
print(len(count))             #格式化输出
count.sort()
if len(count) > 10:
    for j in range(10):
        print(count[j])
else:
    for j in range(len(count)):
        print(count[j])
'''
'''
输入一个字符串，输出其中出现次数最多的字符及其出现的次数，要求使用字典。

输入格式:
输入任意长度字符串。

输出格式:
字符串中出现次数最多的字符及其次数。
'''
'''
a = input()
zd = {}
num = 0
for i in a:
    num += 1

    if i not in zd.keys():
        zd[i] = 1
    else:
        zd[i] += 1

maxn = max(zd.values())

ans = []
tmp = ''
for key,value in zd.items():
    if value == maxn:
        tmp = key
        break
ans.append(tmp)
ans.append(maxn)
print(tuple(ans))
'''
'''
输入两行字符串，以空格为分隔，将每行字符串存储为列表形式。
将第一个列表的元素值作为键，将第二个列表中对应顺序的元素作为值，构建一个字典，按键升序排列后输出字典的所有键值对列表。

输入格式:
输入两行字符串，分别以空格为分隔存为列表。

输出格式:
按键的升序，输出字典键值对列表。
'''
'''
key = input().split()
values = input().split()
zd = {}
for i in range(len(key)):
    for j in range(len(values)):
        if i == j:
            zd[key[i]] = values[j]

result = list(sorted(zd.items()))
print(result)
'''
'''
利用集合分析活动投票情况。第一小队有五名队员，序号是1,2,3,4,5;
第二小队也有五名队员，序号6,7,8,9,10。输入一个得票字符串，求第二小队没有得票的队员

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

输出格式:
一行中输出第二小队没有得票的队员序号。
'''
'''
zd1 = eval(input())
zd2 = eval(input())

for key in zd1:
    if key in zd2.keys():
        zd2[key] += zd1[key]
    else:
        zd2[key] = zd1[key]

n = {}
for key in sorted(zd2.keys()):
    n[key] = zd2[key]

print(n)
'''
'''
输入a,b班的名单，并进行如下统计。

输入格式:
第1行:：a班名单，一串字符串，每个字符代表一个学生，无空格，可能有重复字符。
第2行:：b班名单，一串字符串，每个学生名称以1个或多个空格分隔，可能有重复学生。
第3行:：参加acm竞赛的学生，一串字符串，每个学生名称以1个或多个空格分隔。
第4行：参加英语竞赛的学生，一串字符串，每个学生名称以1个或多个空格分隔。
第5行：转学的人(只有1个人)。

输出格式
特别注意：输出人员名单的时候需调用sorted函数，如集合为x，则print(sorted(x))
输出两个班级的所有人员数量
输出两个班级中既没有参加ACM，也没有参加English的名单和数量
输出所有参加竞赛的人员的名单和数量
输出既参加了ACM，又参加了英语竞赛的所有人员及数量
输出参加了ACM，未参加英语竞赛的所有人员名单
输出参加英语竞赛，未参加ACM的所有人员名单
输出参加只参加ACM或只参加英语竞赛的人员名单
最后一行：一个同学要转学，首先需要判断该学生在哪个班级，然后更新该班级名单，并输出。如果没有在任何一班级，什么也不做。
'''
'''
#按行输入部分
a = list(input())
a = {key:0 for key in a}
b = list(input().split())
b = {key:0 for key in b}
acm = list(input().split())
acm = {key:0 for key in acm}
english = list(input().split())
english = {key:0 for key in english}
trans = list(input())
trans = {key:0 for key in trans}

#下面是按行输出部分
print("Total:",len(a.keys()|b.keys()))
notinrace = sorted((a.keys()-acm.keys()-english.keys())|(b.keys()-acm.keys()-english.keys()))
print("Not in race:",notinrace,",num:",len(notinrace))
allracers = sorted(english.keys() | acm.keys())
print("All racers:",allracers,",num:",len(allracers))
acmenglish = sorted(acm.keys() & english.keys())
print("ACM + English:",acmenglish,",num:",len(acmenglish))
onlyacm = sorted(acm.keys() - english.keys())
print("Only ACM:",onlyacm)
onlyenglish = sorted(english.keys() - acm.keys())
print("Only English:",onlyenglish)
acmorenglish = sorted((english.keys() | acm.keys()) - (acm.keys() & english.keys()))
print("ACM or English:",acmorenglish)

for i in a.keys():
    if i == trans:
     print(sorted(a.keys() - trans.keys()))
     exit(0)
for j in b.keys():
    if j == trans:
     print(sorted(b.keys() - trans.keys()))
     exit(0）
'''
#统计字符串中各字符出现次数
'''
mstr = "Hello world, I am using Python to program, it is very easy to implement."
mlist = list(mstr)
#print(mlist)
mdict = {}      #___(1)___
for e in mlist: #___(2)___

    if mdict.get(e,-1)==-1:
        mdict[e]=1
    else:
        mdict[e]+=1
for key,value in mdict.items():       #___(3)___:
    print (key,value)
'''
'''
每一个列表中只要有一个元素出现两次，那么该列表即被判定为包含重复元素。

编写程序：对n行字符串进行处理，一行字符串构成一个列表。程序判定每一个列表中是否包含重复元素。最后统计包含重复元素的行数与不包含重复元素的行数。

输入格式:
输入n，代表接下来要输入n行字符串。

然后输入n行字符串，字符串之间的元素以空格相分隔。

输出格式:
True=包含重复元素的行数

False=不包含重复元素的行数
'''
'''
n=int(input())
f=0
t=0

for i in range(n):
    s=set()
    a=input().split()
    for j in a:
        s.add(j)
    if len(s)<len(a):
        t+=1
    else:
        f+=1
print("True= {}".format(t))
print("False= {}".format(f))
'''
'''
本题要求编写程序，根据公式
这是一张图片，其实就是排列组合里面的组合公式
算出从n个不同元素中取出m个元素（m≤n）的组合数。

输入格式:
输入在一行中给出两个正整数m和n，以空格分隔。

如果输入数据负数，能输出提示不能负数
如果输入数据出发非法数据，能输出提示请输入数值 (数值异常处理)
输出格式:
按照格式result = 组合数计算结果输出。
'''
'''

def judge(m):
    sum = 1
    for i in range(1, m + 1):
        sum *= i
    return sum


def cal(n, m):
    now_n = judge(n)
    now_m = judge(m)
    now_n_m = judge(n - m)
    return now_n / (now_m * now_n_m)


m, n = list(input().split())
flag = True
flag2 = True
try:
    m, n = int(m), int(n)
except:
    print("请输入数值")
    flag = False
if flag:
    if m > 0 and n > 0:
        print("result={:.2f}".format(cal(n, m)))
    else:
        print("不能负数")
'''
'''
定义一个函数MpSort实现对一组数据的从小大排序。编写程序，实现读入若干个整数存入合适的数据结构类型的对象中。再调用MpSort函数，对该对象中的元素进行排序后输出。

输入格式:
一组用空格隔开的整数。

输出格式:
排序好一组用空格隔开的的整数。例如：尾部带空格。
'''
'''
def MpSort(liebiao):
    flag = 0
    for j in range(len(number)-1):
        if liebiao[j] > liebiao[j+1]:
            liebiao[j],liebiao[j+1] = liebiao[j+1],liebiao[j]
            flag = 1
        if flag == 1:
            MpSort(liebiao)

number = list(map(int, input().split()))
MpSort(number)
for i in number:
    print(i,end = ' ')
'''
'''
设计程序，输入n，输出n×n的田字格。

输入格式:
输入一个0~10之间的整数，n∈［0,10］

输出格式:
使用print函数输出“+”、“-”、“|”以及空格组成的田字格图形（每个方格由四个‘+’号，水平），如输入为0，什么也不输出。
在这里给出一组输入。例如：
1
在这里给出相应的输出。例如：
+ - - - - +
|         |
|         |
|         |
|         |
+ - - - - +
'''

'''
def a(n): #输出行
    for i in range(0, n):
        print("+", end=' ', sep='')
        for j in range(0, 4):
            print("-", end=' ', sep='')
    print("+")

n = int(input())
if n == 0:#为0直接退出程序
    exit(0)

for i in range(0, n):
    a(n)
    for j in range(0, 4):
        for k in range(0, ((4 * n) + n + 1), 5):
            if k == ((4 * n) + n):
                print("|")
            else:
                print("|         ", end='', sep='')
a(n)
'''
'''
把n的Catalan（卡特兰）数表示为h(n)，则有h(1)＝1，h(n)=C(2n,n)/(n+1)（n>1）。
C(n,m)表示组合数；例如，当n=5、m=2时，组合数C(5,3)=(5×4×3)/(3×2×1)=10。

输入格式:
测试数据有多组，处理到文件尾。每组测试输入一个正整数n（1 ≤n ≤ 100）。

输出格式:
对于每组测试，在一行上输出n的Catalan数h(n)。
'''
'''
def catalan(n):
    if n==0 or n==1:
        return 1
    return (4*n-2)*catalan(n-1)/(n+1)

num = int(input())
print(int(catalan(num)))
'''
'''在计算机内部，英文字母依ASCII码分别由连续的整数来表示。比如，大写的英文字母A的ASCII码值为65，B的码值为66，然后依次递增，Z的码值为90。

请编程计算：

从键盘读取大写字母Q（代号，其值由具体输入确定），请问Q所代表的大写字母是字母表中的第几个字母（从1开始计数，即A为第1个字母）？
从键盘读取整数N，求字母表中的第N个字母（从1开始计数）是什么？'''
'''
first = input()
second = int(input())

paixu = ord(first) - 64
zimu = chr(64+second)
print(first,'是字母表中的第',paixu,'个字母',sep='')
print('字母表中的第',second,'个字母是',zimu,sep='')
'''
'''
现要求打印一份员工工资，输入员工的姓名、每小时收入、工作时长，税率和养老金比例，计算员工的净收入并输出相应的信息。
员工的工资 = 每小时收入 * 工作时长
税费 = 工资 * 税率
养老金 = 工资 * 养老金比例
净收入 = 工资 - 税费 - 养老金

输入格式:
输入共5行，每一行依次为员工的姓名、工作时长、每小时收入、税率和养老金比例

输出格式:
依次在每一行输出：姓名、工作小时、每小时收入、工资、扣除金额（保留2位小数）、净收入（保留2位小数）
'''
'''
from decimal import *
name = input()
hours = int(input())
prehours = int(input())
rating = float(input())
yanglao = float(input())


print("Employee Name:",name,end='\n\n')

print("Hours Worked: ",hours)
print("Pay Rate: $",prehours,sep='')
pay = prehours * hours
print("Gross Pay: $",pay,sep='')
kouqian = pay * (rating + yanglao)
print("Deductions:",Decimal(kouqian).quantize(Decimal('0.0')))
daoshou = pay - int(kouqian)
print("Net Pay:",Decimal(daoshou).quantize(Decimal('0.0')),sep='',end='')
'''
'''
格式化输出字符串，控制长度为8个字符，右边对齐，不足补星号

输入样例:
在这里给出一组输入。例如：

abc
输出样例:
在这里给出相应的输出。例如：
*****abc
'''
'''
n = input()
changdu = 0
if len(n) == 8:
    print(n)
elif len(n) < 8:
    changdu = 8 - len(n)
    print("*"*changdu,n,sep='')
'''
'''
规范化输出编号，只有个位数加前导0，否则不变

输入格式:
一个整数
输出格式:
该整数规范化的结果。

输入样例:
在这里给出一组输入。例如：
9
输出样例:
在这里给出相应的输出。例如：
09
'''
'''n = int(input())
if n >= 0 | n <= 9:
    print("0",n,sep='')
elif n >= 10:
    print(n)'''
'''
输入一个正整数，格式化输出整数的二进制形式，输出共8位二进制，不足8位在前面补0

输入格式:
3

输出格式:
00000011
'''
'''n = int(input())
daan = bin(n).replace('0b','')
buwei = 8 - len(daan)
for i in range(buwei):
    print("0",sep='',end='')
print(daan)
'''
'''
编写代码，从键盘输入一个数，判断其是否为素数，结束运行。

输入样例:
7
输出样例:
7是素数
'''
'''import math
n = int(input())

if  n < 0:
    print("判断结束!")
else:
    k = int(math.sqrt(n))
    for i in range(2,k+2):
        if n % i == 0:
            break
        if i == k + 1:
            print(n,'是素数！')
        else:
            print(n,"是合数!")'''

'''
小明在帮助老师统计成绩，老师给他的是一组数据。数据的第1行代表学生数n，后面
的n行代表每个学生的成绩。成绩是整数类型。小明编写了一个程序，该程序可以批量
处理数据，统计所有学生的平均分。当数据没有任何错误时，提示'All OK'，当数据有
一些错误(某行是浮点数、某行是非整数字符)时，可以提示哪些数据出错，并最后提示
第几行出错，出错的原因，共出错多少行。对于另一些小错误，如某行虽然是整数，但
是左右有多余的空格，可以将空格去除掉进行正常统计。

在最后输出：
共处理多少行数据，几行正确，几行错误，平均成绩(保留两位小数)。

进阶要求：
有可能碰到要求输入n行，后面的数据却小于n行。要求处理这种情况。碰到这种情况。
输出end of files，并统计现有行数。见样例3

输入格式:
第1行为n
接下来输入<=n行数据进行测试
输出格式:
见样例输出。输出错误原因的时候，需要将整行输出（如果该行有左右空格，需要将左右空格也输出）

输入样例1:
3
1
    2    
3
输出样例1:
Total: 3
OK: 3
Error: 0
avg grade = 2.00
'''
'''
Total_numb = int(input())
OK_numb = 0
Error_numb = 0
count = 0
list =[]
row = 1

lines = []
while True:
    try:
        lines.append(input())
    except:
        break

for line in lines:
    try:
        keep_data = line
        data = str.strip(keep_data)
        data = eval(data)
    except:
        print(f'line {row} error for input "{keep_data}"')
        Error_numb += 1
    else:
        if type(data) == float:
            print(f'line {row} error for input "{keep_data}"')
            Error_numb += 1
        else:
            list.append(data)
            OK_numb += 1
    finally:
        count += 1
        row += 1

avg = 0
for numb in list:
    avg += numb
avg = avg/len(list)

if count < Total_numb:
    print("end of files")
print(f"Total: {count}")
print(f"OK: {OK_numb}")
print(f"Error: {Error_numb}")
print("avg grade = %.2f"%avg)
'''
'''
本题目要求计算下列分段函数f(x)的值（x为从键盘输入的一个任意实数）：
分段函数1.jpg本题目要求计算下列分段函数f(x)的值（x为从键盘输入的一个任意实数）：

输入格式:
直接输入一个实数给 x，没有其他任何附加字符。

输出格式:
在一行中按“f(x)=result”的格式输出，其中x与result都保留三位小数。

输入格式:
直接输入一个实数给 x，没有其他任何附加字符。

输出格式:
在一行中按“f(x)=result”的格式输出，其中x与result都保留三位小数。
'''
'''import math
x = eval(input())
if math.fabs(x) >= 300:
    y = -1
else:
    a = math.log10(math.fabs(x) + 2.6)
    y = (x**3) / a
print("f({:.3f})={:.3f}".format(x,y))'''


'''
新建一个字符列表，这个列表中的内容从前到后依次包含小写字母、大写字母、数字。 形如['a',...,'z','A',...,'Z','0',...'9']
建议：使用代码生成该字符列表。

分别输入随机数的种子x(整型)，随机生成的密码个数n，每个密码长度m。
每个密码包含的m个字符是从上述字符列表中随机抽取 。
注意：本题不要用sample函数，否则答案错误。

输入格式:
种子x (注意：需将x转换为整数型再进行设置)
密码个数n
每个密码的长度m
'''
'''import string
import random
x = int(input())
random.seed(x)
hang = int(input())
lie = int(input())
s = list(string.ascii_letters + string.digits)
for i in range(hang):
    for j in range(lie):
        print(random.choice(s),end='')
    if i < hang:
        print()
'''

'''
本题要求计算下列分段函数f(x)的值（x为从键盘输入的一个任意实数）：

分段函数&输入输出.jpg
输入格式:
直接输入一个实数x

输出格式:
在一行中按“f(x)=result”的格式输出，其中x与result都保留三位小数。

输入样例:
3.14
输出样例:
f(3.140)=0.865
'''
'''import math
x = float(input())
if math.fabs(x) < 1:
    y = math.sqrt(2 - 2 * x)
elif x >= 1:
    a = math.cos(x) + x ** 2
    y = a / (2.5 + math.fabs(x + math.log(100)))
elif x <= -1:
    y = math.exp(x)
print("f({:.3f})={:.3f}".format(x,y))
'''
'''
同一行中输入m和n二个正整数，n作为seed种子，产生一个4位的随机数验证码，
该随机数作为下一个seed种子，再产生一个4位随机数验证码......直至产生m个随机数验证码。产生的m个随机数验证码按样例输出。

m,n=input().split() #同一行中输入m,n

randint(1000,9999) #生成一个【1000，9999】之间的整数

输入格式:
同一行中输入m和n。二数之间用空隔隔开。

输出格式:
分m行输出。
'''
'''from random import *
m, n = input().split()
m = int(m)
n = int(n)
seed(n)
num = randint(1000,9999)
for i in range(m):
    print(num)
    seed(num)
    num = randint(1000,9999)
'''
'''
使用random库的randint()函数随机产生n道加法题（要求两个加数都是小于10的正整数），
正整数n由用户输入。（注意：先要使用random库的seed(a)函数初始化随机数种子，种子参数为正整数a，由用户输入）

输入格式:
在一行中输入初始化随机数种子参数a（正整数）和题目数量n（小于10的正整数）。

输出格式:
以x+y=的形式输出n道加法题，每行一题。
'''
'''from random import *
a, b = input().split()
a = int(a)
b = int(b)
seed(a)
for i in range(b):
    x = randint(1,9)
    y = randint(1,9)
    print("{0} + {1} = ".format(x,y))'''
'''
每个日期可以转成8位数字，比如 2020年4月28日 对应的就是 20200428。
请找出从现在开始满足条件的1个最近的日期，这个日期中包含m个n数字，m(1<=m<=6）,n(1<=n<=9）由键盘输入。

输入格式:
输入m(1<=m<=6）,n(1<=n<=9），空格分开。

输出格式:
符合要求的日期。
'''