PTA基础题练习4

最新推荐文章于 2023-11-17 14:50:43 发布

梦里逆天

最新推荐文章于 2023-11-17 14:50:43 发布

阅读量376

点赞数

分类专栏：学习笔记文章标签： PTA 编程

本文链接：https://blog.csdn.net/username666/article/details/127020122

版权

学习笔记专栏收录该内容

131 篇文章 20 订阅

订阅专栏

1. 数组元素循环右移

一个数组A中存有N（>0）个整数，在不允许使用另外数组的前提下，将每个整数循环向右移M（≥0）个位置，即将最后M个数循环移至最前面的M个位置。如果需要考虑程序移动数据的次数尽量少，要如何设计移动的方法？

输入格式:

每个输入包含一个测试用例，第1行输入N（1≤N≤100）和M（≥0）；第2行输入N个整数，之间用空格分隔。

输出格式:

在一行中输出循环右移M位以后的整数序列，之间用空格分隔，序列结尾不能有多余空格。

输入样例:
6 2
1 2 3 4 5 6
输出样例:
5 6 1 2 3 4

n, m = map(int, input().strip().split(' '))
numbers = [int(i) for i in input().strip().split(' ')]
m %= n
numbers = numbers[-m:] + numbers[:-m]
print(' '.join(map(str, numbers)))

2. 数字分类

给定一系列正整数，请按要求对数字进行分类，并输出以下 5 个数字：

A₁ = 能被 5 整除的数字中所有偶数的和；
A₂ = 将被 5 除后余 1 的数字按给出顺序进行交错求和，即计算 n₁−n₂+n₃−n₄⋯；
A₃ = 被 5 除后余 2 的数字的个数；
A₄ = 被 5 除后余 3 的数字的平均数，精确到小数点后 1 位；
A₅ = 被 5 除后余 4 的数字中最大数字。

输入格式：

每个输入包含 1 个测试用例。每个测试用例先给出一个不超过 1000 的正整数 N，随后给出 N 个不超过 1000 的待分类的正整数。数字间以空格分隔。

输出格式：

对给定的 N 个正整数，按题目要求计算 A₁~ A₅ 并在一行中顺序输出。数字间以空格分隔，但行末不得有多余空格。

若分类之后某一类不存在数字，则在相应位置输出 N。

输入样例 1：
13 1 2 3 4 5 6 7 8 9 10 20 16 18
输出样例 1：
30 11 2 9.7 9
输入样例 2：
8 1 2 4 5 6 7 9 16
输出样例 2：
N 11 2 N 9

numbers = [int(i) for i in input().strip().split(' ')]
a1 = 0
count_a1 = 0
list1 = []
a3 = 0
a4 = 0
count_a4 = 0
a5 = 0
if numbers[0] <= 1000:
    for number in numbers[1:]:
        if number <= 1000:
            if number % 10 == 0:
                a1 += number
                count_a1 += 1
            if number % 5 == 1:
                list1.append(number)
            if number % 5 == 2:
                a3 += 1
            if number % 5 == 3:
                a4 += number
                count_a4 += 1
            if number % 5 == 4:
                a5 = number if a5 < number else a5
    a1 = a1 if count_a1 > 0 else 'N'
    len_list1 = len(list1)
    a2 = 0
    if len_list1 > 0:
        for i in range(len_list1):
            if i % 2 == 0:
                a2 += list1[i]
            else:
                a2 -= list1[i]
    a2 = a2 if len_list1 > 0 else 'N'
    a3 = a3 if a3 > 0 else 'N'
    a4 = round((a4 / count_a4), 1) if count_a4 > 0 else 'N'
    a5 = a5 if a5 > 0 else 'N'
    print(f'{a1} {a2} {a3} {a4} {a5}')

3. 数素数

令 P_i 表示第 i 个素数。现任给两个正整数 M≤N≤10⁴，请输出 P_M 到 P_N 的所有素数。

输入格式：

输入在一行中给出 M 和 N，其间以空格分隔。

输出格式：

输出从 P_M 到 P_N 的所有素数，每 10 个数字占 1 行，其间以空格分隔，但行末不得有多余空格。

输入样例：
5 27
输出样例：
11 13 17 19 23 29 31 37 41 43
47 53 59 61 67 71 73 79 83 89
97 101 103

import math


def is_prime(n):
    if n == 1:
        return False
    k = int(math.sqrt(n))
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True


m, n = map(int, input().strip().split(' '))
primes = [0, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
num = 31
count1 = 10
while count1 < n:
    if is_prime(num):
        primes.append(num)
        count1 += 1
    num += 2

# print(primes)
count2 = 0
for i in range(m, n + 1):
    count2 += 1
    if count2 % 10 != 0 and i != n:
        print(primes[i], end=' ')
    else:
        print(primes[i])

4. 部分A+B

正整数 A 的“D_A（为 1 位整数）部分”定义为由 A 中所有 D_A 组成的新整数 P_A。例如：给定 A=3862767，D_A=6，则 A 的“6 部分”P_A 是 66，因为 A 中有 2 个 6。

现给定 A、D_A、B、D_B，请编写程序计算 P_A+P_B。

输入格式：

输入在一行中依次给出 A、D_A、B、D_B，中间以空格分隔，其中 0<A,B<10⁹。

输出格式：

在一行中输出 P_A+P_B 的值。

输入样例 1：
3862767 6 13530293 3
输出样例 1：
399
输入样例 2：
3862767 1 13530293 8
输出样例 2：
0

a, b, c, d = map(str, input().strip().split(' '))
# 统计出现次数
count_b_a = a.count(b)
count_d_c = c.count(d)
# print(count_b_a)
# print(count_d_c)
b_a = b * count_b_a if count_b_a > 0 else '0'
d_c = d * count_d_c if count_d_c > 0 else '0'
# print(b_a, d_c)
ans = int(b_a) + int(d_c)
print(ans)

5. 字符统计

找出一段给定文字中出现最频繁的那个英文字母。

输入格式：

输入在一行中给出一个长度不超过 1000 的字符串。字符串由 ASCII 码表中任意可见字符及空格组成，至少包含 1 个英文字母，以回车结束（回车不算在内）。

输出格式：

在一行中输出出现频率最高的那个英文字母及其出现次数，其间以空格分隔。如果有并列，则输出按字母序最小的那个字母。统计时不区分大小写，输出小写字母。

输入样例：
This is a simple TEST.  There ARE numbers and other symbols 1&2&3...........
输出样例：
e 7

str1 = input().strip()
str1 = str1.casefold()
dict_word = {}
max_count = 0
for i in str1:
    if i.isalpha():
        dict_word[i] = str1.count(i)
        if str1.count(i) > max_count:
            max_count = str1.count(i)
list_a = []
for k, v in dict_word.items():
    if v == max_count:
        list_a.append(k)

print(f'{sorted(list_a)[0]} {max_count}')

6. 编程团体赛

编程团体赛的规则为：每个参赛队由若干队员组成；所有队员独立比赛；参赛队的成绩为所有队员的成绩和；成绩最高的队获胜。

现给定所有队员的比赛成绩，请你编写程序找出冠军队。

输入格式：

输入第一行给出一个正整数 N（≤10⁴），即所有参赛队员总数。随后 N 行，每行给出一位队员的成绩，格式为：队伍编号-队员编号成绩，其中队伍编号为 1 到 1000 的正整数，队员编号为 1 到 10 的正整数，成绩为 0 到 100 的整数。

输出格式：

在一行中输出冠军队的编号和总成绩，其间以一个空格分隔。注意：题目保证冠军队是唯一的。

输入样例：
6
3-10 99
11-5 87
102-1 0
102-3 100
11-9 89
3-2 61
输出样例：
11 176

n = int(input().strip())
dict_score = {}
for i in range(n):
    str1 = input().strip().split(' ')
    team_id, p_id = map(int, str1[0].split('-'))
    score = int(str1[1])
    if str(team_id) in dict_score.keys():
        dict_score[str(team_id)] += score
    else:
        dict_score[str(team_id)] = score
list_sort = sorted(dict_score.items(), key=lambda x:x[1], reverse=True)
print(f'{list_sort[0][0]} {list_sort[0][1]}')

7. 有多少不同的值

当自然数 n 依次取 1、2、3、……、N 时，算式 ⌊n/2⌋+⌊n/3⌋+⌊n/5⌋ 有多少个不同的值？（注：⌊x⌋ 为取整函数，表示不超过 x 的最大自然数，即 x 的整数部分。）

输入格式：

输入给出一个正整数 N（2≤N≤10⁴）。

输出格式：

在一行中输出题面中算式取到的不同值的个数。

输入样例：
2017
输出样例：
1480

n = int(input().strip())
numbers = set()  # 定义空集合
for i in range(1, n+1):
    a = int(i / 2)
    b = int(i / 3)
    c = int(i / 5)
    numbers.add(a + b + c)
# 得到集合长度
ans = len(numbers)
print(ans)

8. B是A的多少倍

设一个数 A 的最低 D 位形成的数是 a_d。如果把 a_d 截下来移到 A 的最高位前面，就形成了一个新的数 B。B 是 A 的多少倍？例如将 12345 的最低 2 位 45 截下来放到 123 的前面，就得到 45123，它约是 12345 的 3.66 倍。

输入格式：

输入在一行中给出一个正整数 A（≤10⁹）和要截取的位数 D。题目保证 D 不超过 A 的总位数。

输出格式：

计算 B 是 A 的多少倍，输出小数点后 2 位。

输入样例 1：
12345 2
输出样例 1：
3.66
输入样例 2：
12345 5
输出样例 2：
1.00

list1 = input().strip().split(' ')
a, b = list1[0], list1[1]
c = a[-int(b):] + a[:-int(b)]
# print(c)
ans = int(c) / int(a)
print('%.2f' % ans)

9. 销量冠军

在试卷列表中，系统列出了每份试卷的单价及当前的购买人次。请你根据这些信息找出所有试卷中的销量（即购买人次）冠军和销售额冠军。

输入格式：

输入首先在第一行中给出一个正整数 N（≤10⁴），随后 N 行，每行给出一份卷子的独特 ID （由小写字母和数字组成的、长度不超过8位的字符串）、单价（为不超过 100 的正整数）和购买人次（为不超过 10⁶ 的非负整数）。

输出格式：

在第一行中输出销量冠军的 ID 及其销量，第二行中输出销售额冠军的 ID 及其销售额。同行输出间以一个空格分隔。题目保证冠军是唯一的，不存在并列。

输入样例：
4
zju007 39 10
pku2019 9 332
pat2018 95 79
qdu106 19 38
输出样例：
pku2019 332
pat2018 7505

n = int(input().strip())
products = []
max_sales = 0
max_sales_value = 0
for i in range(n):
    product_ID, price, sales = input().strip().split(' ')
    # print(product_ID, price, sales)
    if max_sales < int(sales):
        max_sales = int(sales)
    if max_sales_value < int(price) * int(sales):
        max_sales_value = int(price) * int(sales)
    products.append(
        {'ID': product_ID, 'price': int(price), 'sales': int(sales), 'sales_value': (int(price) * int(sales))})
# print(products)
for product in products:
    if product['sales'] == max_sales:
        print(f'{product["ID"]} {product["sales"]}')
for product in products:
    if product['sales_value'] == max_sales_value:
        print(f'{product["ID"]} {product["sales_value"]}')