python练习6——PTA - 代码天地

7-1 重复元素查找 (100 分)

每一个列表中只要有一个元素出现两次，那么该列表即被判定为包含重复元素。

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

输入格式:

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

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

输出格式:

True=包含重复元素的行数

False=不包含重复元素的行数

输入样例:

5
1 a 3 c 5
a 3 c 5 d
b 2 3 b 1
x 2 w 2 w
a 1 1 1 1

结尾无空行

输出样例:

True= 3
False= 2

n=int(input())
true=n
#想用whilen--
for i in range(n):
    tmp=map(str,input().split())#细想
    tmp=list(tmp)#想一下，是把字典里哪些东西变成了列表
    if len(tmp)==len(set(tmp)):
        true-=1
print("True= %d\nFalse= %d" %(true,n-true))

# 7-2 jmu-python-组合数 (20 分)

本题要求编写程序，根据公式

算出从n个不同元素中取出m个元素（m≤n）的组合数。

输入格式:

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

如果输入数据负数，能输出提示不能负数
如果输入数据出发非法数据，能输出提示请输入数值 (数值异常处理)

输出格式:

按照格式result = 组合数计算结果输出。

输入样例:

2 7

结尾无空行

输出样例:

result=21.00

结尾无空行

def jc(x):
    ans=1
    for i in range(1,x+1):
        ans*=i
    return ans
while True:
    try:
            flag=True
            str=input()
            m,n=map(int,str.split())
            if m<0 or n<0:
                print("不能负数")
                flag=False
            else:
                pass
            break
    except:
            print("请输入数值")
            flag=False
            break
if flag==False:
    exit(0)
end=0.0
#print(jc(n))
end=jc(n)/(jc(m)*jc(n-m))
print("result=%.2lf" %end)

# 7-3 递归算法实现冒泡排序算法的函数MpSort (20 分)

定义一个函数MpSort实现对一组数据的从小大排序。编写程序，实现读入若干个整数存入合适的数据结构类型的对象中。再调用MpSort函数，对该对象中的元素进行排序后输出。

输入格式:

一组用空格隔开的整数。

输出格式:

排序好一组用空格隔开的的整数。例如：尾部带空格。

输入样例:

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

1 3 5 7 4 2 6 8 10 9

结尾无空行

输出样例:

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

1 2 3 4 5 6 7 8 9 10

结尾无空行

str=input()#之后试试按题目要求的
li=[]
li=map(int,str.split())
li=sorted(li)
for i in li:
    print(i,end=" ")

# 7-4 大型田字格 (10 分)

设计程序，输入n，输出n×n的田字格。

输入格式:

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

输出格式:

使用print函数输出“+”、“-”、“|”以及空格组成的田字格图形（每个方格由四个‘+’号，水平），如输入为0，什么也不输出。

输入样例:

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

结尾无空行

输出样例:

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

+ - - - - +
|         |
|         |
|         |
|         |
+ - - - - +

结尾无空行

输入样例:

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

结尾无空行

输出样例:

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

+ - - - - + - - - - + - - - - + - - - - +
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
+ - - - - + - - - - + - - - - + - - - - +
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
+ - - - - + - - - - + - - - - + - - - - +
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
+ - - - - + - - - - + - - - - + - - - - +
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
|         |         |         |         |
+ - - - - + - - - - + - - - - + - - - - +

结尾无空行

h=[1,6,11,16,21,26,31,36,41,46,51]
n=int(input())
if n==0:
    exit(0)
c=5*n+1
for i in range(1,c+1):
    for j in range(1,c+1):
        if i in h and j in h:
            print("+",end="")
        elif i not in h and j not in h:
            print(" ",end="")
            pass
        elif i in h and j not in h:
            print("-",end="")
        else:
            print("|",end="")
        if j!=c:
            print(" ",end="")
        else:
            pass
    print()

7-5 Catalan数 (10 分)

把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)。

输入样例:

输出样例:

import sys

for line in sys.stdin:
    n = int(line)
    if n < 1 or n > 100:
        break
    m = 2 * n
    u = d = 1
    for x in range(n):
        u *= m - x
        d *= n - x
    h = int(u / d / (n + 1))
    print(h)
    if line == '\n':
        break

7-7 求矩阵中的逆鞍点 (10 分)

求出n×m二维整数数组中的所有逆鞍点。这里的逆鞍点是指在其所在的行上最大，在其所在的列上最小的元素。若存在逆鞍点，则输出所有逆鞍点的值及其对应的行、列下标。若不存在逆鞍点，则输出“Not”。要求至少使用一个自定义函数。

输入格式:

测试数据有多组，处理到文件尾。每组测试的第一行输入n和m（都不大于100），第二行开始的n行每行输入m个整数。

输出格式:

对于每组测试，若存在逆鞍点，则按行号从小到大、同一行内按列号从小到大的顺序逐行输出每个逆鞍点的值和对应的行、列下标，每两个数据之间一个空格；若不存在逆鞍点，则在一行上输出“Not”（引号不必输出）。

输入样例:

3 3
97 66 96
85 36 85
88 67 91
3 4
73 89 74 76
6 33 74 0
27 57 6 32

输出样例:

85 1 0
85 1 2
Not

while True:
    try:
        # 按行按列分别存为列表好查找最大最小
        n, m = map(int, input().split(" "))
        mp = {}  # hang
        mp1 = {}  # lie
        for i in range(1, n + 1):
            tmp = list(map(int, input().split()))
            mp[i] = tmp
            # print("行元素")
            # print(mp[i])
        tmp = []
        for j in range(1, m + 1):
            tmp = []
            for i in range(1, n + 1):
                tmp.append(mp[i][j - 1])
            mp1[j] = tmp
            # print("列元素")
            # print(mp1[j])
        num = 0
        for i in range(1, n + 1):
            for j in range(1, m + 1):
                if mp[i][j - 1] == max(mp[i]) and mp[i][j - 1] == min(mp1[j]):
                    num += 1
                    print("{} {} {}".format(mp[i][j - 1], i - 1, j - 1))
        if num == 0:
            print("Not")
    except:
        break

7-8 旋转方阵 (10 分)

对于一个奇数n阶方阵，请给出经过顺时针方向m次旋转后的结果。

输入格式:

测试数据有多组，处理到文件尾。每组测试的第一行输入2个整数n，m（1<n<20，1≤m≤100），接下来输入n行数据，每行n个整数。

输出格式:

对于每组测试，输出奇数阶方阵经过m次顺时针方向旋转后的结果。每行中各数据之间留一个空格。

输入样例:

输出样例:

这个明明测试样例都可以过，就是答案错误，给我整不明白了，暂时附上只能过测试样例的代码

while True:
    try:
        keyindex=[]
        tmp=[]
        tmp.append(0)
        n,m=map(int,input().split())
        m=m%4
        for i in range(n):
            tmp=tmp+input().split()#哟西，所有的值都存储进去了
            # print(tmp)
        if m==0:
            for i in range(1,n*n+1):
                if i%n!=0:
                    print(tmp[i],end=" ")
                elif i%n==0:
                    print(tmp[i])
        elif m==1:
            for i in range(1,n+1):
                for j in range(1,n+1):
                    tt = (3 - j) * n + i
                    if j!=n:
                        print(tmp[tt],end=" ")
                    elif j==n:
                        print(tmp[tt])
        elif m==2:
            for i in range(1, n + 1):
                for j in range(1, n + 1):
                    tt = (3-i)*n+(3-j+1)
                    if j != n:
                        print(tmp[tt], end=" ")
                    elif j == n:
                        print(tmp[tt])
        elif m==3:
            for i in range(1, n + 1):
                for j in range(1, n + 1):
                    tt = (3-i+1)+(j-1)*n
                    if j != n:
                        print(tmp[tt], end=" ")
                    elif j == n:
                        print(tmp[tt])
    except:
        break

# 7-9 整数转换为字符串 (10 分)

将一个整数n转换成字符串。例如；输入483，应得到字符串"483"。其中，要求用一个递归函数实现把一个正整数转换为字符串。

输入格式:

首先输入测试组数T，然后输入T组测试数据。每组测试数据输入一个整数n（-2^31≤n≤2^31-1）。

输出格式:

对于每组测试，输出转换后的字符串。

输入样例:

1
1234

输出样例:

n=int(input())#想一下之后按题目要求的来
for i in range(n):
    str=input()
    print(str)

# 7-10 进制转换 (10 分)

将十进制整数n（−231≤n≤231−1）转换成k（2≤k≤16）进制数。注意，10~15分别用字母A、B、C、D、E、F表示。

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据输入两个整数n和k。

输出格式:

对于每组测试，先输出n，然后输出一个空格，最后输出对应的k进制数。

输入样例:

输出样例:

#队列
t=int(input())
flag=1
for i in range(t):
    flag=1
    n,m=map(int,input().split())
    if n == 0:
        print("0 0")
        continue
    ans1=n
    ans=""
    while True:
        try:
            if n==0:
                break
            elif n<0:
                n=abs(n)
                flag=-1
            else:
                tmp=n%m

                if tmp>=10 and tmp<=15:
                    tmp=65+(tmp-10)
                    # print(chr(tmp))
                    ans+=chr(tmp)
                else:
                    ans+=str(tmp)
                    # print(str(tmp))
                n=n//m
        except:
            break
    # ans.reverse()
    print("%d"%ans1,end=" ")
    if flag == -1:
        print("-",end="")
    for i in range(len(ans)-1,-1,-1):
        print(ans[i],end="")
    print()

7-11 最长的单词 (10 分)

输入一个字符串，将此字符串中最长的单词输出。要求至少使用一个自定义函数。

输入格式:

测试数据有多组，处理到文件尾。每组测试数据输入一个字符串（长度不超过80）。

输出格式:

对于每组测试，输出字符串中的最长单词，若有多个长度相等的最长单词，输出最早出现的那个。这里规定，单词只能由大小写英文字母构成。

输入样例:

Keywords insert, two way insertion sort,
Abstract This paper discusses three method for two way insertion
words. insert, two way sorted.

输出样例:

insertion
discusses
insert

false=[]
kk=[]
kk.append('!')
kk.append('.')
kk.append(',')
kk.append(':')
kk.append('*')
kk.append('?')
def solve(qq):
    # print("嘿嘿")
    aa=sorted(qq.items(), key=lambda d: (d[1]), reverse=True)
    # print(type(aa))
    for i in range(len(aa)):
        print(aa[i][0])
        break
    """maxn=max(qq.values())
    print(maxn)
    anss=d4.index(maxn)
    print(anss)"""
while True:
    try:
        false1=''
        false=input()
        if len(false)==1 or len(false)==0:
            exit(0)
        for i in range(0,len(false)):
            if false[i] in kk:
                false1+=' '
            else:
                false1+=false[i]
        tmp=map(str,false1.split())
        tmp=list(tmp)
        # print(tmp)
        qq={}
        for i in range(len(tmp)):
            qq[tmp[i]]=len(tmp[i])
        # print(qq)
        solve(qq)
    except:
        break

7-12 按日期排序 (10 分)

输入若干日期，按日期从小到大排序。

输入格式:

本题只有一组测试数据，且日期总数不超过100个。按“MM/DD/YYYY”的格式逐行输入若干日期。

输出格式:

按“MM/DD/YYYY”的格式输出已从小到大排序的各个日期，每个日期占一行。

输入样例:

输出样例:

出处:

ZJUTOJ 1045

# 弄个比较时间的函数，诶其实可以直接按字典的键排序，键是列表
# 把每一个转换为数字，直接排序，再输出对应的字符串
tmp1 = []  # 用来存储转后的数字
# 字符串可以按下标操作吗
tmp = []
j=-1
while True:
    try:
        j+=1
        str1=""
        str1 = input()
        tmp.append(str1)
        a = str1[:2]
        b = str1[3:5]
        c = str1[-4:]
        tmp1.append(int(c+a+b))
    except:
        break
tmp1.sort()
# print("嘿嘿")
# print(tmp1)

for i in tmp1:
    dd=str(i)
    # print(dd)
    print("{}/{}/{}".format(dd[-4:-2],dd[-2:],dd[:-4:]))
"""12/31/2005
10/21/2003
02/12/2004
11/12/1999
10/22/2003
11/30/2005
"""

7-13 母牛问题 (10 分)

设想一头小母牛从第4个年头开始每年生育一头小母牛。现有一头小母牛，按照此设想，第n年时有多少头母牛？

输入格式:

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

输出格式:

对于每组测试，输出第n年时的母牛总数。

输入样例:

5
8
15

输出样例:

3
9
129

出处:

ZJUTOJ 1182

#原本以为和斐波拉切数列一样要递推，结果，，，，
def mow(n):
    if n<=3:
        return 1
    else:
        return mow(n-1)+mow(n-3)
while True:
    try:
        n=int(input())
        print(mow(n))
    except:
        break

7-15 五位以内的对称素数 (10 分)

判断一个数是否为对称且不大于五位数的素数。要求判断对称和判断素数各写一个函数。

输入格式:

测试数据有多组，处理到文件尾。每组测试输入一个正整数n（0 < n < 232）。

输出格式:

对于每组测试，若n是不大于五位数的对称素数，则输出“Yes”，否则输出“No”。每个判断结果单独占一行。注意：引号不必输出。

输入样例:

输出样例:

Yes
Yes
No
Yes
No

出处:

ZJUTOJ 1187

import math as m
def dc(x):
    x=str(x)
    n=len(x)//2
    for i in range(n):
        if x[i]!=x[-i-1]:
            return False#不对称
    return True
def ss(x):
    n=m.sqrt(x)
    n=int(n)
    while True:
        if n==1:
            return True
        elif x%n==0:
            return False#非素数
        else:
            n-=1
while True:
    try:
        n=int(input())
        if n<=99999 and ss(n) and dc(n):
            print("Yes")
        else:
            print("No")
    except:
        break

7-16 输入三角形三边长，求三角形面积（高教社，《Python编程基础及应用》习题3-8） (3 分)

编程序实现功能：输入三角形的三条边边长，求三角形面积，其中面积计算使用用户自定义函数实现。输出的面积保留两位小数。

输入格式:

边长1
边长2
边长3

输出格式:

当三条边可能构成合法的三角形时，输出应为：

面积

当三条边无法构成合法的三角形时，输出：

数据错误

输入样例:

3
4
5

结尾无空行

输出样例:

6.00

结尾无空行

提示：面积计算可使用海伦公式；两边之和大于第3边；两边之差小于第3边。

拼尽全力还是不会？参考B站习题讲解

哔哩哔哩up主：海洋饼干叔叔 Python课程 Python习题简洁的C和C++

import math as m
a=int(input())
b=int(input())
c=int(input())
ans=0.00
def s(a,b,c):
    p=(a+b+c)/2
    return m.sqrt(p*(p-a)*(p-b)*(p-c))
def judge(a,b,c):
    if a+b>c and b+c>a and a+c>b:
        return True
    else:
        return False
if judge(a,b,c):
    print("%.2lf"%s(a,b,c))
else:
    print("数据错误")

7-17 最短跑道长度（高教社，《Python编程基础及应用》习题3-12 (3 分)

假设某飞机的加速度是a，起飞的速度是v，下述公式可以计算出该飞机起飞所需的最短跑道长度: L = v2/(2a)。编写一个程序，提示用户输入起飞速度v(m/s)和加速度a(m/s2)，计算飞机起飞的最短跑道长度，输出时保留2位小数。计算过程宜封装成一个函数，该函数接受参数v和a，返回计算所得的L。

输入样例:

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

100
5

结尾无空行

输出样例:

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

最短跑道长度为:1000.00

结尾无空行

提示：本题中的冒号均为英文冒号。

拼尽全力还是不会？参考B站习题讲解

哔哩哔哩up主：海洋饼干叔叔 Python课程 Python习题简洁的C和C++

#厉害了还提供题解视频链接
import math as m
v=int(input())
a=int(input())
ans=0
def l(v,a):
    ans=v*v/(2*a)
    return ans
print("最短跑道长度为:%.2lf"%l(v,a))

7-18 快速幂 (10 分)

输入两个整数a、b，求ab。结果保证在long long int范围内。

输入格式:

测试数据有多组，处理到文件尾。每组测试输入两个正整数a，b（1≤a，b≤62）。

输出格式:

对于每组测试，输出ab的结果。

输入样例:

2 4

输出样例:

def qpow(a, n):
    if (n == 0):
        return 1;
    elif (n % 2 == 1):
        return qpow(a, n - 1) * a
    else:
        temp = qpow(a, n / 2)
        return temp * temp
while True:
    try:   
        a,b=map(int,input().split())
        print(qpow(a,b))
    except:
        break

7-19 列表元素升序组成整数 (10 分)

输入一个列表，其中每个元素都是0～9之间的整数，输出由该列表的所有元素升序排序后组成的整数。

输入格式:

输入一个列表，其中每个元素都是0～9之间的整数。

输出格式:

输出由列表的所有元素升序排序后组成的整数。

输入样例:

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

[5, 4, 7, 4, 1]

结尾无空行

输出样例:

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

结尾无空行

输入样例:

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

[0, 3, 4, 1]

结尾无空行

输出样例:

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

结尾无空行

str1=eval(input())
str1=sorted(str1)
# print(str)
flag=False
ans=""
for i in range(len(str1)):
    if str1[i]==0 and flag==False:
        # print(str1[i])
        continue
    else:
        flag=True
        # print(str1[i])
        ans+=str(str1[i])
        # print(ans)
    # print(flag)
print(ans)

7-21 斐波那契数列 (10 分)

意大利数学家斐波那契（Leonardo Fibonacci）是12、13世纪欧洲数学界的代表人物。他提出的“兔子问题”引起了后人的极大兴趣。 “兔子问题”假定一对大兔子每一个月可以生一对小兔子，而小兔子出生后两个月就有繁殖能力，问从一对小兔子开始，n个月后能繁殖成多少对兔子？

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试输入一个正整数n（1≤n≤46）。

输出格式:

对于每组测试，输出n个月后能繁殖成的兔子对数。

输入样例:

1
4

输出样例:

"""def f(n):
    if n == 1 or n == 2:
        return 1
    return f(n - 1) + f(n - 2)
t=int(input())
ans=[]
for i in range(1,17):
    ans.append(f(i))
print(ans)
for i in range(t):
    tmp=int(input())
    print(f(tmp))
exit(0)"""


class Solution:
    def Fibonacci(self, n):
        # write code here
        fib = [0,1]
        for i in range(2,n+1):
            fib.append(fib[i-1]+fib[i-2])
        return fib[n]
t = int(input())
s = Solution()
for i in range(t):
    tmp=int(input())
    print(s.Fibonacci(tmp))

7-22 统计各行业就业的学生数量，按数量从高到低方式输出。 (20 分)

键盘输入某班各个同学就业的行业名称，行业名称之间用空格间隔(回车结束输入) 。统计各行业就业的学生数量，按数量从高到低方式输出。

输入格式:

输入各个同学行业名称，行业名称之间用空格间隔（回车结束输入）

交通金融计算机交通计算机计算机

输出格式:

输出参考格式如下，其中冒号为英文冒号：

计算机：3

交通：2

金融：1

输入样例:

交通 金融 计算机 交通 计算机 计算机

结尾无空行

输出样例:

计算机：3 
交通：2 
金融：1

结尾无空行

tmp=map(str,input().split())
tmp=list(tmp)
end={}
for i in range(len(tmp)):
    if tmp[i] in end:
        end[tmp[i]]+=1
    else:
        end[tmp[i]]=1
ans={}
# for value in end.values():
ans= sorted( end.items(),key = lambda x:x[1],reverse = True)
num=len(ans)
ans=dict(ans)
for key,value in ans.items():
    print("{}:{}".format(key,value))

7-23 键盘输入学习的课程名称及考分等信息并计算 (15 分)

键盘输入学习的课程名称及考分等信息，屏幕输出得分最高的课程及成绩，得分最低的课程及成绩，以及平均分(保留2位小数)。

输入格式:

键盘输入学习的课程名称及考分等信息，信息间采用空格分隔，每个课程一行，空行回车结束录入。

输出格式:

屏幕输出得分最高的课程及成绩，得分最低的课程及成绩，以及平均分(保留2位小数)。

输入样例:

示例格式如下：

数学 90 
语文 95 
英语 86 
物理 84 
生物 87

结尾无空行

输出样例:

最高分课程是语文95，最低分课程是物理84， 平均分是88.40

结尾无空行

"""sc=[]
avg1=0
ans={}
j=0
while True:
    try:
        tmp = input()
        if tmp.strip()=="":
            # print("空格")
            break
        j+=1
        tmp=tmp.split()
        a=int(tmp[1])
        b=str(tmp[0])
        sc.append(a)
        ans[b]=a
        # print(ans)
    except:
        break
avg1=sum(sc)/len(sc)
i=0
minn=0
maxn=0
minname=""
maxname=""
for value in sorted(ans.values()):
    i+=1
    if i==1:
        minn=value
        # print(minn)
    elif i==j:
        maxn=value
        # print(maxn)
    else:
        continue
for key in ans.keys():
    if ans[key]==minn:
        minname=key
    elif ans[key]==maxn:
        maxname=key
    else:
        continue
# print("最高分课程是%s%d, 最低分课程是%s%d,  平均分是%.2lf"%(maxname,maxn,minname,minn,avg1),end="")
print("最高分课程是{}{}, 最低分课程是{}{}, 平均分是{:.2f}".format(maxname, maxn, minname, minn, avg1))"""
data = input()
ls = data.split()
min_score = int(ls[1])
min_name = ls[0]
max_score = int(ls[1])
max_name = ls[0]
n = 0
sum = 0
while data:
    n += 1
    lt = data.split()
    if min_score > int(lt[1]):
        min_score = int(lt[1])
        min_name = lt[0]
    if max_score < int(lt[1]):
        max_score = int(lt[1])
        max_name = lt[0]
    sum += int(lt[1])
    data = input()
avg = sum / n
print("最高分课程是{}{}, 最低分课程是{}{}, 平均分是{:.2f}".format(max_name, max_score, min_name, min_score, avg))
#why，最后一个测试点过不了

7-24 多个数的最小公倍数 (10 分)

两个整数公有的倍数称为它们的公倍数，其中最小的一个正整数称为它们两个的最小公倍数。当然，n个数也可以有最小公倍数，例如：5，7，15的最小公倍数是105。输入n个数，请计算它们的最小公倍数。

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。每组测试先输入一个整数n（2≤n≤20），再输入n个正整数（属于[1，100000]范围内）。这里保证最终的结果在int型范围内。

输出格式:

对于每组测试，输出n个整数的最小公倍数。

输入样例:

2
3 5 7 15
5 1 2 4 3 5

输出样例:

105
60

def gcd(a,b):
    if b==0:
        return a
    else:
        return gcd(b,a%b)
def lcm(a,b):
    return a/gcd(a,b)*b
t=int(input())
for i in range(t):
    tmp=map(int,input().split())
    tmp=list(tmp)
    del tmp[0]
    tmp=set(tmp)
    # print(tmp)
    tmp=list(tmp)
    ans=0
    tmp1=lcm(tmp[0],tmp[1])
    if len(tmp)==2:
        ans=lcm(tmp[0],tmp[1])#考虑小地方，两个的时候得到
    for i in range(2,len(tmp)):
        tmp1=lcm(tmp[i],tmp1)
        ans=tmp1
    print(int(ans))