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

今天终于零零散散吧题目写完了，晚上再来写思路吧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[0]:
            return 1
        elif a[0]

 首先使用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[0]:
            return 1
        elif a[0]

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[2]:
            return -1
        elif a[2]b[3]:
                return -1
            elif a[3]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

 先初始化列表，输入数据进行计算维护，然后将元组使用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

这题认识了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[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...