吉首大学21级python暨大数据应用开发语言实验三----PTA习题集解答

JSU_曾是此间年少

已于 2023-04-05 15:02:00 修改

阅读量1.6k

点赞数 1

文章标签： python

于 2022-10-10 20:45:06 首次发布

本文链接：https://blog.csdn.net/m0_72678953/article/details/127252039

版权

今天终于零零散散吧题目写完了，晚上再来写思路吧1 0.15

完成 10.18

修改了两个填空题的答案10.20

学弟们一定要记得7-22 输出全排列，这个题目啊啊啊啊

import itertools from permutation

for 循环+permutation（string s,int n）

我们期末考了，但是我不记得了，啊啊啊啊啊啊

不过还好，数据很水

学长手写了一个全排列过了【滑稽.jpg】

2-10代码

i=1
while i<=5:
    num=1
    for j in range(1,i+1):
        print(num,end="G")
        num+=2
    print()
    i+=1

2-11

for i in range(1,4):
    for j in range(1,4):
        if j%2==0:
            break
        print("{:3d}".format(i*j),end="")
    if i %2==0:
        break

2-12

num=int(input())
a=num-1
while a>1:
    if num%a==0:
        print("哈哈")
        break
    a=a-1
else:
    print("嘻嘻")

2-13

i=1
s=0
while i<10:
    if i%2==0:
        continue
    else:
        s+=i
    print(i)
    i=i+1
print(s)

2-14

balance=20
while True:
    if balance<9:
        break
    balance-=9
print("balance is {}".format(balance))

2-15

for i in range(1,4):
    for j in range(1,4):
        print("%3d"%(i*j),end="")
        if j%2==0: break

最后一个填空题

def main():
    s=[12,-4,32,-36,12,6,-6]
    s_max,s_sum=0,0
    for i in range(len(s)):
        s_sum+=s[i]
        if s_sum>=s_max:
            s_max=s_sum
        elif s_sum<0:
            s_sum=0
    print(s_max)

main()

代码放这里，你们自己去运行一下，一定要自己试一下

------------------------------------------------------------------------------------------------------

单选题

1-5 AABCD

6-10 BABBB

11-15 ABDAC

------------------------------------------------------------------------------------------------------

填空题

1 .DGH

2. DBH

3. AHI

4. 40

5. 1 3 5

6. 4 40 12 6

------------------------------------------------------------------------------------------------------

编程题

首先我们解决结构体排序的板子问题

我们拿第四题当模板，很多题目都可以这样套，比如第二题

7-35 jmu-Java&Python-统计文字中的单词数量并按出现次数排序

from functools import cmp_to_key

def mycmp(a,b):
    if a[1]>b[1]:
        return -1
    elif a[1]<b[1]:
        return 1
    else:
        if a[0]>b[0]:
            return 1
        elif a[0]<b[0]:
            return -1

str1=input()
dirs={}
sum=0
while str1!="!!!!!":
    str1=str1.replace("!"," ").replace("."," ").replace(","," ").replace(":"," ").replace("*"," ").replace("?"," ")
    str1=str1.lower()
    list1=(" ".join(str1.split(" "))).split()
    sum+=len(list1)
    for i in list1:
        dirs[i]=dirs.get(i,0)+1
    str1 = input()
    
ans=sorted(dirs.items(),key=cmp_to_key(mycmp))
print(len(dirs))
for i in range(10):
    print(ans[i][0], end="")
    print("=", end="")
    print(ans[i][1])

首先使用replace（）方法删除掉脏数据，然后统一转换为小写，

再使用“ ”.join()来格式化空格，详情请参见往期写的字符串操作方法，存进列表

计算单词个数（当前行列表元素个数）

将单词作为key，出现次数作为值，

再接受下一行数据

使用字典的排序方法，以及自定义排序

输出排序后的数据的前十个

下面是我的原始注释版

from functools import cmp_to_key

def mycmp(a,b):
    #先比较a[1]  降序
    # 再比较a[0] 升序
    if a[1]>b[1]:
        return -1
    elif a[1]<b[1]:
        return 1
    else:
        if a[0]>b[0]:
            return 1
        elif a[0]<b[0]:
            return -1

str1=input()
dirs={}
sum=0#单词的数量
while str1!="!!!!!":

    #要求从文中删除指定字符  replace()  --非原地操作
    str1=str1.replace("!"," ").replace("."," ").replace(","," ").replace(":"," ").replace("*"," ").replace("?"," ")
    #转换为小写
    str1=str1.lower()
    #print("str1="+str1)
    #格式化空格
    list1=(" ".join(str1.split(" "))).split()
    sum+=len(list1)
    #print(len(list1))
    #print(listk1)
    #将每个列表里面的元素数量统计放进字典
    for i in list1:
        dirs[i]=dirs.get(i,0)+1
    str1 = input()
#ans=sorted(dirs.items(),key=lambda x:(x[1],x[0]),reverse=False)
ans=sorted(dirs.items(),key=cmp_to_key(mycmp))
#print(sum)
print(len(dirs))
#print(ans)
#输出前十个

for i in range(10):
    #print("{}={}".format(ans[0],ans[1]))
    print(ans[i][0], end="")
    print("=", end="")
    print(ans[i][1])

7-32 通过两个列表构建字典

str1=input().split()
str2=input().split()
dir1=dict(zip(str1,str2))
#压缩成字典的步骤  --两个列表变成字典---使用zip
list1=list(dir1.items())
#只写字典名称 是一个由键组成的列表  要返回键值元组的列表需要调用列表的items()函数
#变成列表，方便排序  样例最外面有括号
list1.sort()
print(list1)

板子题目

7-33 足球联赛排名

from functools import cmp_to_key #排序函数必须用到的

def mycmp(a,b):#比较函数
    if a[1]>b[1]:
        return -1
    elif a[1]<b[1]:
        return 1
    else:
        if a[2]>b[2]:
            return -1
        elif a[2]<b[2]:
            return 1
        else:
            if a[3]>b[3]:
                return -1
            elif a[3]<b[3]:
                return 1
            else:
                if a[0]>b[0]:
                    return 1
                return -1

T=int(input())#测试组数

for i in range(T):
    n=int(input())
    # 初始化数据  0舍弃掉
    jifen =     [0 for i in range(n+1)]#积分
    win_num =   [0 for i in range(n+1)]#净胜球
    all_num =   [0 for i in range(n+1)]#总进球
    num =       [i  for i in range(n+1)]#编号

    line=int((n*(n-1))/2)#行数
    for t in range(line):
        i,j,p,q=map(int,input().split())
        #输入一行四个数据
        #计算维护
        if p>q:
            jifen[i]+=3
            win_num[i]+=p-q
            win_num[j]-=p-q
        elif p<q:
            jifen[j]+=3
            win_num[j]+=q-p
            win_num[i]-=q-p
        else:
            jifen[i]+=1
            jifen[j]+=1
            
        all_num[i]+=p
        all_num[j]+=q
    #输入完毕

    list2=list(zip(num,jifen,win_num,all_num))
    list2.pop(0)
    ans=sorted(list2,key=cmp_to_key(mycmp))
    #print(list2)
    list_ans=[]
    for i in range(n):
        list_ans.append(ans[i][0])
    # print(" ".join(list_ans))
    #有数字，不能直接转换
    list_ans_copy=[]#初始化一个空列表
    for i in list_ans:
        list_ans_copy.append(str(i))
    print(" ".join(list_ans_copy))

先初始化列表，输入数据进行计算维护，然后将元组使用zip变成元组列表，

删除掉第一个为空的数据，进行排序

建立一个新列表，将排序结果放入其中输出即可

模板题，多看看，就眼熟了

7-34 使用字符串的索引和切片知识输入月份数字，输出英文月份缩写

Mouth={
    1:"Jan",
    2:"Feb",
    3:"Mar",
    4:"Apr",
    5:"May",
    6:"Jun",
    7:"Jul",
    8:"Aug",
    9:"Sept",
    10:"Oct",
    11:"Nov",
    12:"Dec"
}
ans=int(input())
print(Mouth[ans])

打表输出

7-36 jmu-python-随机生成密码

import random,string
x=int(input())      #输入随机数种子
random.seed(x)      #载入随机数种子
line=int(input())   #行数
width=int(input())  #宽度
list1=list(string.ascii_letters+string.digits)
#确定列表
for i in range(line):
    for j in range(width):
        print(random.choice(list1),end="")
    if i<line-1:
        print()

这题认识了string库里面的ascii_letters和string.digits

还有random里面的choice

7-37 jmu-python-重复元素判定

n=int(input())
suma=0  #有重复
sumb=0  #无重复

# for i in range(n):
#     list_test=list(map(int,input().split()))
#     f=True
#     list_copy=set(list_test)
#     for i in list_copy:
#         if list_test.count(i)>=2:
#             suma+=1
#             f=False
#             break
#     if f==True:
#         sumb+=1
for i in range(n):
    list_test = input().split()
    if len(list_test)==len(set(list_test)):
        sumb+=1
    else:
        suma+=1
print("True={}, False={}".format(suma,sumb))

艹，一开始想复杂了，其实直接比较原列表的长度和该列表形成的集合长度就可以了

有重复元素一定长度不相等，判断长度即可

7-38 jmu-python-生日悖论

import random,string
x,n=map(int,(input().split()))      #输入随机数种子
random.seed(x)      #载入随机数种子
num=0

for i in range(n):
    ans = []
    for j in range(23):
        ans.append(random.randint(1,365))
        #start--end
    if len(ans)!=len(set(ans)):
        num+=1
print("rate={:.2f}".format(num/n))

random.randint()函数

这一题说明随机数种子是一个伪随机

7-39 列表或元组的数字元素求和

# list1=eval(input())
# print(list1)
# sum_num=0
# for i in list1:
#     # print(i,type(i))
#     if type(i)==str:
#         #特判
#         # sum_num+=int(i) str直接跳过
#         continue
#     elif type(i)==int or type(i)==float:
#         sum_num+=i
#     else:
#         #其他类型元素
#         sum_num+=sum(i)
# print(sum_num)
x = eval(input())
def Sum(x):
    sums = 0
    for ch in x:
        if isinstance(ch, int):
            sums += ch
        if isinstance(ch, list):
            sums += Sum(ch)#列表中嵌套层次不限2层,要用递归
        if isinstance(ch, tuple):
            sums += Sum(ch)#列表中嵌套层次不限2层,要用递归
    return sums

print(Sum(x))

四种情况：（遍历递归）

整型----直接求和

列表----进行迭代

元组---进行迭代

下面的几道纯列表题都一样，直接一起解析了

7-40 列表数字元素加权和(1)

ls=eval(input())  
def s(ls,level):   
    sum=0    
    for i in ls:    
        if type(i) == int:   
            sum+=i*level    
        else:                   
            sum+=s(i,level+1)    
    return sum    
sum=s(ls,1)    
print(sum)

7-41 列表数字元素加权和(2)

ls=eval(input())
def s(ls,level):
    sum=0
    time=pow(-1,level+1)*level
    for i in ls:

        if type(i) == int:
            sum+=i*time
        else:
            sum+=s(i,level+1)
    return sum
sum=s(ls,1)
print(sum)

7-42 列表元素个数的加权和(1)

ls=eval(input())
def s(ls,level):
    sum=0
    for i in ls:

        if type(i) == int:
            sum+=level
        else:
            sum+=s(i,level+1)
    return sum
sum=s(ls,1)
print(sum)

7-43 列表元素的个数加权和(2)

ls=eval(input())
def s(ls,level):
    sum=0
    for i in ls:

        if type(i) == int:
            sum+=11-level
        else:
            sum+=s(i,level+1)
    return sum
sum=s(ls,1)
print(sum)

7-44 求指定层的元素个数

ls=eval(input())
dic={}

def s(ls,level):
    sum=0
    for i in ls:

        if type(i) == int:
            dic[str(level)]=dic.get(str(level),0)+1
        else:
            sum+=s(i,level+1)
    return sum
sum=s(ls,1)
level=int(input())
print(dic[str(level)])

#加到字典里面，吧层数当做索引，元素个数当做值

一个纯列表的递归模板

如果含有其他东西则需要修改一下

这里利用了eval（）函数--评估函数

评估函数

直接将列表字符串转为列表，666

这些题目根据题目要求改一下就好了

基本思想都是对列表里面的元素进行类型判断，可迭代迭代，不需要跳过，需要返回结果直接相加

7-45 溢出控制

while True:
    try:
        n=int(input())
        ans=pow(2,8*n-1)-1
        print(ans)
    except:
        break

7-46 缩写期刊名

n=int(input())
for i in range(n):
    str1=input().lower()#转为小写
    list1=str1.split()
    list2=[]
    for j in list1:
        if len(j)>4:
            list2.append(j[0:4]+".")
        else:
            list2.append(j)
    print(" ".join(i for i in list2))

7-47 多项式相加


n =input().split(",")
m =input().split(",")
index=int(input())
list1=[]

#遍历第二个位置的最大值
max=-1
coun=0
for i in n:
    tup1=tuple(i.split())
    list1.append(tup1)
    if int(list1[coun][1])>max:
        max=int(list1[coun][1])
    #print(type(int(list1[coun][1])))
    coun+=1
# print(max)
for i in m:
    tup1 = tuple(i.split())
    list1.append(tup1)
    if int(list1[coun][1]) > max:
        max = int(list1[coun][1])
    # print(type(int(list1[coun][1])))
    coun += 1
list2=[0 for i in range(max+1)]
for i in list1:
    list2[int(i[1])]+=int(i[0])
print(list2[index])

这个算法有点不稳定，使用字典会更好

这个是采用他最大值为多少然后进行生成列表，比较不稳定

找到最大值

7-48 字典合并与排序

a=eval(input())
b=eval(input())
# print(b)
# print(type(a))
for key1, value1 in a.items():
    if key1 in b:
        b[key1] += value1
    else:
        b[key1] = value1
dic = sorted(zip(b.keys(),b.values()))  #打包成元组进行排序
# print(dic)
d={}
for i in range(len(dic)):
    d[dic[i][0]] = dic[i][1]
print (d)

吧两个字典加到一个字典里面去，其实如果键不存在也可以使用数组索引形式

666

使用zip打包形成元组，并且元组sorted（）默认按第一个元素升序排列

7-49 解析车间里的阀门状态

value=eval(input())
status = int(value[0])
#将b右边的字符转换为ASCII码值
ans=[]
for i in range(8):
    st = (bool)((status>>i)&0x01)
    # 10进制 ：1    题目里面的二进制： 01
    #int型的和16进制的数据进行与运算取最低位
    #题目里面的输出倒着输出，可以使用右移运算符依次取最低
    #print(f'第{i}位：{st}')
    ans.append(str(st))
print("[",end="")
print(", ".join(ans),end="")
print("]")

7-19 jmu-python-九九乘法表（矩形）


for i in range(1,10):
    for j in range(1,10):
        rule="{:8}"
#         print(rule.format("%d*%d=%d"%(i,j,i*j)),end="")
        print(rule.format("{}*{}={}".format(i, j, i * j)), end="")
    
    print()

一个很坑的点是测试样例是没有那个题目所给的样例的多余的两个回车

直接这样就行，太蠢了

注意这个新的保留一定宽度输出，后面用到的ljust（）也可以

比如说这样子：


for i in range(1,10):
    for j in range(1,10):
        #rule="{:8}"
#         print(rule.format("%d*%d=%d"%(i,j,i*j)),end="")
        print("{}*{}={}".format(i, j, i * j).ljust(8), end="")
    
    print()

7-20 jmu_python_最大公约数&最小公倍数

def gcd(a,b):
    if b==0:
        return a
    if a>=b:
        a,b=b,a
    return gcd(a,b%a)

# print(gcd(3,4))
a,b=map(int,input().split(','))
print("GCD:{:.0f}, LCM:{:.0f}".format(gcd(a,b),a*b/gcd(a,b)))

板子题目，
注意是右边那个数为0则返回左边那个数

如果左边大于右边则交换一下

然后再次递归（左边（交换后），大%小）

最后得到结果

7-21 jmu-python-凯撒密码加密算法

str1=input()
n=int(input())
for i in str1:
    if i.isalpha()==True:
        if chr(ord(i)+n).isalpha()==False:
            print(chr(ord(i)+n-26),end="")
        else:
            print(chr(ord(i)+n),end="")

    else:
        print(i,end="")

chr（）ord（）的用法

7-22 输出全排列

from itertools import permutations
n = int(input())
a = [str(i) for i in range(1,n+1)]
# print(a)
s = "".join(a)
# print(s)
# sum=0
for i in permutations(s,n):
    print("".join(i))
#     sum+=1
# print(sum)

调用permutaions（）库函数

7-23 打印特殊三角形

n=int(input())
start=0
for i in range(1,n+1):
    start=i
    list1=[]
    add=n
    for j in range(n-i+1):
        str1=str(start)
        if len(str1)<2:
            str1+=" "
        list1.append(str1)
        start+=add
        add-=1
    print(" ".join([str(k) for k in list1 ]).rstrip())

一个很傻逼的点是需要自己观察他是每个数字占两个的规律

（表现为三格，实际上由于列表自动隔一个空格，所以数字输出时只格式化为两格）

我们只需在添加字符串数字的时候判断一下长度，不够右边补0即可

但是这样就会使得最右边结尾有多出空格（题目是不能要的）

所以得使用.rstrip（）方法

7-24 班级排队

from  functools import cmp_to_key
def mycmp(a,b):
    #性别降序
    #身高升序
    if a[1]>b[1]:
        return -1
    elif a[1]<b[1]:
        return 1
    else:
        if a[0]>b[0]:
            return 1
        return -1

n=int(input())
#实际上这个n没有用
list1=list(map(int,input().split()))
list2=list(map(int,input().split()))
list3=list(zip(list1,list2))

ans=sorted(list3,key=cmp_to_key(mycmp))
print(" ".join(str(i[0]) for i in ans))

一个题目，三个知识点，可以当做入门题会好一点

7-25 漂亮的螺旋

n=int(input())
#生成仿真数组
list_ans=[[0]*n for i in range(n)]
# print(list_ans)
num=n*n
index_x=n-1
index_y=n-1
f=1
#1 2 3 4
#表示左上右下

#开始填充数组
while num!=0:
    list_ans[index_x][index_y]=str(num)
    ################################
    if f==1 :    #左
        if index_y-1>=0 and list_ans[index_x][index_y-1]==0:
            #左边没出界而且值为0
            index_y-=1
        else:
            f=2
            index_x-=1
    elif f==2:  #上
        if index_x-1>=0 and list_ans[index_x-1][index_y]==0:
            #上边没出界而且值为0
            index_x-=1
        else:
            f=3
            index_y+=1
    elif f == 3:  # 右
        if index_y + 1 <= n-1 and list_ans[index_x ][index_y+1] == 0:
            # 右边没出界而且值为0
            index_y += 1
        else:
            f = 4
            index_x += 1
    elif f == 4:  # 下
        if index_x + 1 <= n - 1 and list_ans[index_x+1][index_y ] == 0:
            # 下边没出界而且值为0
            index_x += 1
        else:
            f = 1
            index_y -= 1
    ################################
    num-=1
# for i in list_ans:
#     print(i)
#将列表里的元素格式化输出
for i in list_ans:
    for index,j in enumerate(i):
        #准备获取尾部地址
        if index!=len(i)-1:
            print(str(j).ljust(4),end="")
            #题目的问题
        else:
            print(str(j), end="")
    print()

三个步骤

1.初始化坐标

2.###以内的是坐标的维护

3.使用enumerate（）返回其元素与下标的组合

使用.ljust()输出

7-26 兔子跳楼梯

n=int(input())
if n<=2:
    if n==0:
        print("0")
    elif n==1:
        print("1")
    else:
        print("2")

else :
    list1 = [0] * (n + 1)
    list1[1] = 1
    list1[2] = 2
    # print(list1)
    for i in range(n + 1):
        if i == 0 or i == 1 or i == 2:
            continue
        list1[i] = list1[i - 1] + list1[i - 2]
    # 分解子问题
    # print(list1)

    print(list1[n])

简单动态规划

我还水了一道力扣，hhh

7-27 模拟报数游戏（约瑟夫环问题）

ans=[i+1 for i in range(int(input()))]
# ans.pop(0)
# print(ans)
d=int(input())
index=d-1
while len(ans)!=1:
    index%=len(ans)
    ans.pop(index)
    index+=d-1

    #print(ans)
print("[{}]".format(ans[0]))

有了pop()这个特性，python解决这类动态变化长度数组是真的强

原本还以为这个pop()只有副作用，没想到这里用上了

我们只需要再pop它的后面第n-1个元素就好了

注意维护下标防止越界

7-28 就区间正整数内所有素数之和

def is_pri(n):
    if n==1:
        return False
    for i in range(n):
        if i==0 or i==1:
            continue
        if n%i==0:
            return False
    return True

a,b=map(int,input().split())
#测试点0
if a>b:
    a,b=b,a
b+=1
sum=0
f=False
for i in range(a,b):
    if is_pri(i)==True:
        sum+=i
        f=True
#测试点12
if f==False:
    print("not have prime!")
else:
    print(sum)

注意题目要求即可

7-29 输出<=n的全部回文数

def print_hw_num(num):
    str1=str(num)
    str2=str1[::-1]
    #字符串也可以使用列表的操作
    if str1==str2:
        print(num)
#把数字的每一位放进列表
x=int(input())

if x>=10:
    #gfgf
    for i in range(x+1):
        if i<10:
            print(i)
        else:
            print_hw_num(i)
else:
    for i in range(x+1):
        print(i)

我的方法是使用反转然后判断是否相等

判断id也行理论上

7-30 列表生成及循环左移

n=int(input())
list1=[i+1 for i in range(n)]

list1.pop(0)
list1.append(1)
print(list1)

删除list[0] 他的值为1

然后在末尾吧1加回去

7-31 奖金计算，循环与多分支

x=eval(input())
sum=0.0
if x>1000000:
    sum+=(x-1000000)*0.01
    x=1000000
if x>600000:
    sum+=(x-600000)*0.015
    x=600000
if x>400000:
    sum+=(x-400000)*0.03
    x=400000
if x>200000:
    sum+=(x-200000)*0.05
    x=200000
if x>100000:
    sum+=(x-100000)*0.075
    x=100000
if x>=0:
    sum+=x*0.1
    print("{:.2f}".format(sum))
else:
    print("0.00")

这个题目是正常的？？？

7-50 字典的应用-找出出现次数最多的字符串

x=input()
newdict={}
max_str=""
max_num=0
while True:
    if x=="q":
        break;
    #newdict[x]+=1
    newdict[x] = newdict.get(x, 0) + 1
    if newdict[x]>max_num:
        max_num=newdict[x]
        max_str=x
    x = input()
print(max_str,newdict[max_str])

大水题

数据量大的时候，加到列表里面然后排序会快一点

7-51 统计输入字符串中的单词个数及单词的平均长度

def all_list(arr):
    ans={}
    for i in set(arr):
        ans[i]=arr.count(i)
    return ans
# total=input()
# x=total.split(" ")
# #print(x)
# len_x=len("".join(total.split())) #原始字符串不包含空格的长度
# #print(len_x)
# num=len(x)  #单词个数
# size=len(set(x))#元素个数
#求字母个数 求单词长度 求单词个数
#求单词个数
ans=input()
num=len(list(ans.split()))
#求单词长度
str1="".join(ans.split())
lens=len(str1)
#求字母个数
aph_num=len(set(str1))

print("{},{:.2f}".format(num,lens/num))

艹，一开始想复杂了

看清题目就好

7-52 对于给定的正整数N，求它的位数及其各位数字之和。

str1=input()
x=int(str1)

def fun_len(n):
    len=0
    sum=0
    while n!=0:

        len+=1
        sum+=int(n)%10
        n //= 10
    return [len,sum]
s=fun_len(x)

print(s[0],s[1])

哈哈哈，python可以返回两个参数，666

7-53 求输入数字的平方，如果平方运算后小于50则退出

#正确代码示例：
num = float(input())
while True:
    num*=num
    print("{}".format(num ))
    if num  <= 50:
        break
    num = float(input())

#错误代码示例：
#对23
# num = eval(input())
# while True:
#     num*=num
#     print("{}".format(num ))
#     if num  <= 50:
#         break
#     num = eval(input())
#     #对23
#这是原先的代码

eval（）有坑，但是我没找到

这道题目全部用float，千万不要用eval，问老师老师不给样例QAQ...