PTA乙级题

1035 插入与归并 (25 分)

（这题是我抄的，哭泣）
根据维基百科的定义：

插入排序是迭代算法，逐一获得输入数据，逐步产生有序的输出序列。每步迭代中，算法从输入序列中取出一元素，将之插入有序序列中正确的位置。如此迭代直到全部元素有序。

归并排序进行如下迭代操作：首先将原始序列看成 N 个只包含 1 个元素的有序子序列，然后每次迭代归并两个相邻的有序子序列，直到最后只剩下 1 个有序的序列。

现给定原始序列和由某排序算法产生的中间序列，请你判断该算法究竟是哪种排序算法？

输入格式：
输入在第一行给出正整数 N (≤100)；随后一行给出原始序列的 N 个整数；最后一行给出由某排序算法产生的中间序列。这里假设排序的目标序列是升序。数字间以空格分隔。

输出格式：
首先在第 1 行中输出Insertion Sort表示插入排序、或Merge Sort表示归并排序；然后在第 2 行中输出用该排序算法再迭代一轮的结果序列。题目保证每组测试的结果是唯一的。数字间以空格分隔，且行首尾不得有多余空格。

输入样例 1：
10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0
结尾无空行
输出样例 1：
Insertion Sort
1 2 3 5 7 8 9 4 6 0
结尾无空行
输入样例 2：
10
3 1 2 8 7 5 9 4 0 6
1 3 2 8 5 7 4 9 0 6
结尾无空行
输出样例 2：
Merge Sort
1 2 3 8 4 5 7 9 0 6
结尾无空行

#输入待排序的数字个数
n=int(input())
#输入待排序的列表
a_0=list(map(int,input().split()))
#输入经过排序的列表
a_1=list(map(int,input().split()))
 
 
#a=b:将b的地址赋值给a，如果a改变了，b也会改变
#a=b[:]:使用[:]对列表整体切片，相当于开辟了一个新的地址空间，将新空间的地址赋值给a，a的改变并不影响b
#由于判断排序方式会对列表的本身产生改变，所以为了不影响进一步的判断，我们创建新的列表来保存要进行排序的数据
b_0=a_0[:]
b_1=a_1[:]
c_0=a_0[:]
c_1=a_1[:]
 
 
#插入排序
def Insertion_Sort(unsorted_list,contrast_list):
    #用来控制for循环的结束
    flag=1
    #待排序列表的长度
    length=len(unsorted_list)
    #从头开始排序
    for i in range(1,length):
        flag=flag+1
        #当前值的前一个值的索引
        j=i-1
        #如果前一个值大于当前值
        if unsorted_list[j]>unsorted_list[i]:
            #则将当前的值暂时储存
            temp=unsorted_list[i]
            #如果前一个值的索引大于等于0，且前一个值大于当前值，则循环持续进行
            while j>=0 and unsorted_list[j]>temp:
                #将前一个值放置在当前值的位置上
                unsorted_list[j+1]=unsorted_list[j]
                #继续往前判断
                j=j-1
            #最后将暂时储存的值放置在合适的位置上
            unsorted_list[j+1]=temp
        #循环结束
        if flag==200:
            #按规定格式输出经过了一次排序的待排序数字列表
            print('Insertion Sort')
            print(' '.join(list(map(str,unsorted_list))))
            #循环结束
            break  
        #如果两个数字列表相等，则证明该排序是直接插入排序
        #这个给flag赋值要放在break后面，否则会产生死循环
        if unsorted_list==contrast_list:
            #设定标记使循环完成下一次时就结束
            flag=199
        
 
#归并排序
def Merge_Sort(unsorted_list,contrast_list):
    #用来控制while循环的结束
    flag=1
    #待排序列表的长度
    length=len(unsorted_list)
    #控制归并列表段的长度
    i=1
    #当归并列表段的长度小于待排序列表的长度时，持续进行归并排序
    while i<=length :
        flag=flag+1
        #每次循环，归并列表段的长度都要大一倍
        i=i*2
        #当i与待排序列表长度length相同时，for循环无法启动，所以预先设置j为0
        j=0
        for j in range(i,length,i):
            unsorted_list[j-i:j]=sorted(unsorted_list[j-i:j],reverse=False)
        #当剩下的长度不够一个归并列表段时，此句将剩下的部分排序
        #当i与待排序列表的长度相同时，将整个待排序列表排序
        unsorted_list[j:length]=sorted(unsorted_list[j:length],reverse=False)
        #循环结束
        if flag==200:
            #按规定的格式输出经过了一次排序的待排序数字列表
            print('Merge Sort')
            print(' '.join(list(map(str,unsorted_list))))
            #循环结束
            break
        #如果两个数字列表相等，则证明该排序是归并排序
        #这个给flag赋值同样要放在break后面，否则会产生死循环
        if unsorted_list==contrast_list :
            #设定标记，使循环完成下一次时就结束
            flag=199
            
 
#归并排序测试
Merge_Sort(c_0,c_1)
 
 
#插入排序测试
Insertion_Sort(b_0,b_1)

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

美国总统奥巴马不仅呼吁所有人都学习编程，甚至以身作则编写代码，成为美国历史上首位编写计算机代码的总统。2014 年底，为庆祝“计算机科学教育周”正式启动，奥巴马编写了很简单的计算机代码：在屏幕上画一个正方形。现在你也跟他一起画吧！

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

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

输入样例：
10 a
结尾无空行
输出样例：
aaaaaaaaaa
a a
a a
a a
aaaaaaaaaa
结尾无空行

N, st = input().split()
N = int(N)
li = (N + 1) // 2
print(N * st)
for i in range(0, li - 2):
    print(st, (N - 2) * ' ', st, sep='')
print(N * st)

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

P, A = input().split()
P = str(P)
A = str(A)
Galleon1, Sickle1, Knut1 = map(int, P.split('.'))
Galleon2, Sickle2, Knut2 = map(int,A.split('.'))

biubiubiu = Galleon1 * 17 * 29 + Sickle1 * 29 + Knut1
dengdeng = Galleon2 * 17 * 29 + Sickle2 * 29 + Knut2
zheizhei = dengdeng - biubiubiu

if zheizhei>= 0:
    Galleon3, Knut3 = divmod(zheizhei, 493)
    Sickle3, Knut3 = divmod(Knut3, 29)
    print(Galleon3, Sickle3, Knut3,sep='.')
else:
    zheizhei = abs(zheizhei)
    Galleon3, Knut3 = divmod(zheizhei, 493)
    Sickle3, Knut3 = divmod(Knut3, 29)
    print("-",end='')
    print(Galleon3, Sickle3, Knut3,sep='.')

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

先声明，我写的是错的，运行超时
本题要求读入 N 名学生的成绩，将获得某一给定分数的学生人数输出。

输入格式：
输入在第 1 行给出不超过 10
5
的正整数 N，即学生总人数。随后一行给出 N 名学生的百分制整数成绩，中间以空格分隔。最后一行给出要查询的分数个数 K（不超过 N 的正整数），随后是 K 个分数，中间以空格分隔。

输出格式：
在一行中按查询顺序给出得分等于指定分数的学生人数，中间以空格分隔，但行末不得有多余空格。

输入样例：
10
60 75 90 55 75 99 82 90 75 50
3 75 90 88
结尾无空行
输出样例：
3 2 0

N = int(input())
score = list(map(int,input().split()))
search = list(map(int,input().split()))
c = search[0]
search.remove(search[0])
number = []
num = 0
for e in search:
    num = score.count(e)
    number.append(num)


print(*number)

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。

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

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

输入样例：
4
0.1 0.2 0.3 0.4
结尾无空行
输出样例：
5.00
结尾无空行
感谢 Ruihan Zheng 对测试数据的修正。

#这是我的，请注意我的是错的
N = int(input())
blist = []
alist = list(map(eval,input().split()))
clist = []
fin = 0
if N % 2 == 0:
    flag = N
    for i in range(1, N // 2 + 1, 1):
        blist.append(i * flag)
        flag = flag - 1
    temp = blist[::-1]
    clist = blist+temp
    for j in range(N):
        fin = fin + (alist[j] * clist[j])
else:
    flag = N
    for i in range(1, N // 2 + 2, 1):
        blist.append(i * flag)
        flag = flag - 1
    temp = blist[0:len(blist)-1][::-1]
    temp.reverse()
    clist = blist+temp
    for j in range(N):
        fin = fin + (alist[i] * clist[i])

print("%.2f" % fin)

下面这个是对的
来源：https://blog.csdn.net/qq_40728667/article/details/108097617?spm=1001.2014.3001.5501

from decimal import Decimal
 
n=int(input())
 
 
#将浮点数都转换为Decimal类型，防止float计算结果不够精确的问题
#Convert all floating-point numbers to decimal type
#Prevent the problem of insufficient accuracy of floating-point calculation results
a=list(map(Decimal,input().split(' ')))
 
 
result=Decimal(0)
 
 
#a[i]在所有的片段中出现了(i+1)*(n-i)次
#a[i] appears (i+1)*(n-i) times in all fragments
for i in range(n):
    result=result+a[i]*(i+1)*(n-i)
    
 
#使用quantize取小数点后两位并按格式输出
#Use quantize to take two digits after the decimal point and output according to the format
print(result.quantize(Decimal('0.00')))

//规律着实惊我，比我的简单多了……

1050 螺旋矩阵 (25 分)

本题要求将给定的 N 个正整数按非递增的顺序，填入“螺旋矩阵”。所谓“螺旋矩阵”，是指从左上角第 1 个格子开始，按顺时针螺旋方向填充。要求矩阵的规模为 m 行 n 列，满足条件：m×n 等于 N；m≥n；且 m−n 取所有可能值中的最小值。

输入格式：
输入在第 1 行中给出一个正整数 N，第 2 行给出 N 个待填充的正整数。所有数字不超过 10
4
，相邻数字以空格分隔。

输出格式：
输出螺旋矩阵。每行 n 个数字，共 m 行。相邻数字以 1 个空格分隔，行末不得有多余空格。

输入样例：
12
37 76 20 98 76 42 53 95 60 81 58 93
结尾无空行
输出样例：
98 95 93
42 37 81
53 20 76
58 60 76

import math
a = int(input())
b = [int(i) for i in input().split()]
if a==1:
    print(b[0],end="")
else:
    b.sort(reverse = True)
    b=list(map(str,b))
    if math.sqrt(a)%1==0:
        m=int(math.sqrt(a))
    else:
        m =int(math.sqrt(a)+1)
    while a%m!=0:
        m+=1
    n = a//m
    matrix = [[0 for i in range(n)] for i in range(m)]
    k = 0
    i = 0
    j = 0
    l = 0
    while k<a:
        while k<a and i<n-1:
            matrix[j][i]=b[k]
            i+=1
            k+=1
        while k<a and j<m-1:
            matrix[j][i]=b[k]
            j+=1
            k+=1
        while k<a and i>l:
            matrix[j][i]=b[k]
            i-=1
            k+=1
        while k<a and j>l:
            matrix[j][i]=b[k]
            j-=1
            k+=1
        i,j,l,m,n=i+1,j+1,l+1,m-1,n-1
        if k==a-1:                    
            matrix[j][i]=b[k]
            k+=1
    for i in matrix:
        print(" ".join(i))

#我的我不理解二维列表是怎么弄，失败